@brunoluizdesiqueira/bbuilder-cli 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Bruno Siqueira
+
+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,211 @@
+# bbuilder-cli
+
+CLI em Node.js/TypeScript que substitui o `build_local.bat` com interface interativa e suporte a flags diretas.
+
+---
+
+## Instalação
+
+```bash
+# Desenvolvimento local
+npm install
+npm run build
+npm link        # disponibiliza o comando 'delphi' globalmente
+```
+
+```bash
+# Instalação via npm
+npm install -g @brunoluizdesiqueira/bbuilder-cli
+```
+
+```bash
+# Publicação
+npm publish --access public
+```
+
+Ou use direto sem instalar globalmente:
+```bash
+npx ts-node src/index.ts build
+```
+
+---
+
+## Uso
+
+### Modo interativo (sem argumentos)
+```bash
+delphi
+```
+Exibe menus para escolher: modo de build → projeto → versão.
+
+### Comando `build` com flags opcionais
+```bash
+delphi build                                         # interativo completo
+delphi build --type DEBUG                            # escolhe projeto e versão interativamente
+delphi build --type FAST --project faturamento\BimerFaturamento
+delphi build --type RELEASE --project Bimer --version 11.3.1
+```
+
+### Atalhos diretos por modo
+```bash
+delphi fast                                          # interativo para projeto/versão
+delphi debug --project Bimer
+delphi release --project Bimer --version 11.3.1
+```
+
+### Gerenciamento de projetos
+```bash
+delphi project list     # lista projetos configurados
+delphi project add      # adiciona novo projeto (interativo)
+```
+
+### Configuração do ambiente
+```bash
+delphi config init      # assistente para criar bbuilder.config.json
+delphi config show      # exibe configuração atual
+```
+
+---
+
+## Configuração (`bbuilder.config.json`)
+
+Prioridade de resolução da configuração:
+
+1. `delphi --config <caminho>`
+2. Variável de ambiente `BBUILDER_CONFIG`
+3. `bbuilder.config.json` no diretório atual
+4. `bimer.config.json` no diretório atual, por compatibilidade
+5. Arquivo global do usuário
+
+No Windows, o arquivo global fica em `%APPDATA%\bbuilder-cli\bbuilder.config.json`.
+
+Crie com `delphi config init`, ou manualmente:
+
+```json
+{
+  "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",
+  "dependencyPaths": [
+    "C:\\git\\bimer\\dependencies",
+    "C:\\Program Files (x86)\\Embarcadero\\Studio\\22.0\\lib\\Win64\\release",
+    "C:\\LibraryDelphiAlexandria\\Externos\\3.00\\sgcWebSockets\\Win64",
+    "C:\\LibraryDelphiAlexandria\\ERP\\11.03.00\\Win64"
+  ],
+  "projects": {
+    "BimerFaturamento": "faturamento\\BimerFaturamento",
+    "Bimer": "Bimer",
+    "LiberadorEstoque": "geral\\gerenteeletronico.jobs.liberadorestoque\\LiberadorEstoque",
+    "BimerEstoque": "estoque\\BimerEstoque"
+  }
+}
+```
+
+`dependencyPaths` deve ser ajustado no `bbuilder.config.json`, porque esses caminhos podem variar entre usuários e máquinas.
+
+`projects` agora usa o formato `nome amigável: caminho real do projeto`, para a CLI exibir nomes humanizados sem perder a referência correta de compilação.
+
+Se o arquivo não existir, os valores padrão acima são usados automaticamente. Ao rodar `delphi config init`, a CLI gera um `dependencyPaths` inicial com base nos diretórios informados.
+
+Exemplos:
+
+```bash
+delphi --config C:\configs\bbuilder.config.json build
+```
+
+```bash
+set BBUILDER_CONFIG=C:\configs\bbuilder.config.json
+delphi config show
+```
+
+---
+
+## Integração com VSCode (`tasks.json`)
+
+Substitua o `tasks.json` atual por este (sem mais menus do VSCode, a CLI cuida de tudo):
+
+```json
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "label": "Bimer: FAST + Run",
+      "type": "shell",
+      "command": "delphi fast",
+      "group": "build",
+      "presentation": { "reveal": "always", "focus": true, "panel": "dedicated", "clear": true },
+      "problemMatcher": {
+        "owner": "delphi",
+        "fileLocation": ["autoDetect", "${workspaceFolder}"],
+        "pattern": {
+          "regexp": "^(.*?)\\s*\\((\\d+)\\)(?:\\s+|:\\s*)(Fatal|Error|Warning|Hint|error|fatal):\\s+(.*)$",
+          "file": 1, "line": 2, "severity": 3, "message": 4
+        }
+      }
+    },
+    {
+      "label": "Bimer: DEBUG + Run",
+      "type": "shell",
+      "command": "delphi debug",
+      "group": "build",
+      "presentation": { "reveal": "always", "focus": true, "panel": "dedicated", "clear": true },
+      "problemMatcher": {
+        "owner": "delphi",
+        "fileLocation": ["autoDetect", "${workspaceFolder}"],
+        "pattern": {
+          "regexp": "^(.*?)\\s*\\((\\d+)\\)(?:\\s+|:\\s*)(Fatal|Error|Warning|Hint|error|fatal):\\s+(.*)$",
+          "file": 1, "line": 2, "severity": 3, "message": 4
+        }
+      }
+    },
+    {
+      "label": "Bimer: RELEASE",
+      "type": "shell",
+      "command": "delphi release",
+      "group": "build",
+      "presentation": { "reveal": "always", "focus": true, "panel": "dedicated", "clear": true },
+      "problemMatcher": {
+        "owner": "delphi",
+        "fileLocation": ["autoDetect", "${workspaceFolder}"],
+        "pattern": {
+          "regexp": "^(.*?)\\s*\\((\\d+)\\)(?:\\s+|:\\s*)(Fatal|Error|Warning|Hint|error|fatal):\\s+(.*)$",
+          "file": 1, "line": 2, "severity": 3, "message": 4
+        }
+      }
+    }
+  ]
+}
+```
+
+E nos keybindings, nada muda — os atalhos continuam os mesmos.
+
+---
+
+## Estrutura do Projeto
+
+```
+bbuilder-cli/
+├── src/
+│   ├── build/
+│   ├── cli/
+│   ├── config/
+│   ├── ui/
+│   ├── index.ts
+│   └── types.ts
+├── package.json
+├── tsconfig.json
+└── README.md
+```
+
+## Stack
+
+| Lib | Por quê |
+|---|---|
+| **commander** | Parsing de comandos e flags |
+| **inquirer** | Menus interativos com setas |
+| **chalk** | Cores ANSI no terminal |
+| **execa** | Spawn de processos externos (CGRC, DCC64) |
+| **typescript** | Tipagem, autocomplete, menos bugs |

package/dist/build/compiler.js

@@ -0,0 +1,140 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildCompilerFlags = buildCompilerFlags;
+exports.runCgrc = runCgrc;
+exports.runDcc64 = runDcc64;
+exports.runBuiltExecutable = runBuiltExecutable;
+const execa_1 = __importDefault(require("execa"));
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const output_1 = require("../ui/output");
+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,
+                runAfter: true,
+            };
+        case 'DEBUG':
+            return {
+                flags: ['-B', '-$W+', '-$J+', '-$D+', '-$L+', '-$Y+', '-$O-', '-V', '-VR'],
+                defines: baseDefines,
+                runAfter: true,
+            };
+        case 'RELEASE':
+            return {
+                flags: ['-B', '-$W+', '-$J+', '-$D0', '-$L-', '-$Y-', '-$O+'],
+                defines: releaseDefines,
+                runAfter: false,
+            };
+    }
+}
+function buildDependencies(opts) {
+    return opts.dependencyPaths.map(p => `"${p}"`).join(';');
+}
+async function runCgrc(opts, projectName) {
+    const tempDir = path.join(os.tmpdir(), `BimerBuild_${projectName}`);
+    const vrcFile = path.join(tempDir, `${projectName}.vrc`);
+    const resFile = path.join(tempDir, `${projectName}.res`);
+    (0, output_1.step)('Compilando recursos e embutindo ícone...');
+    try {
+        await (0, execa_1.default)(path.win32.join(opts.delphiDir, 'bin', 'cgrc.exe'), [vrcFile, `-fo${resFile}`], { stdio: 'inherit' });
+    }
+    catch {
+        (0, output_1.fatal)('Falha do compilador CGRC ao gerar o arquivo de recursos .res.');
+    }
+    return resFile;
+}
+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');
+    if (!fs.existsSync(exeOut))
+        fs.mkdirSync(exeOut, { recursive: true });
+    if (!fs.existsSync(dcuOut))
+        fs.mkdirSync(dcuOut, { recursive: true });
+    (0, output_1.step)(`Iniciando compilação do código fonte (${opts.type})...`);
+    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`,
+    ];
+    try {
+        await (0, execa_1.default)(dcc64, args, {
+            cwd: workspaceDir,
+            stdio: 'inherit',
+        });
+    }
+    catch {
+        (0, output_1.fatal)('Falha na compilação do Delphi. Verifique os logs de erro acima.');
+    }
+}
+function runBuiltExecutable(opts, projectName) {
+    const { runAfter } = buildCompilerFlags(opts.type);
+    if (!runAfter)
+        return;
+    const exeOut = path.win32.join('C:\\Temp', opts.envVersion, 'EXE', `${projectName}.exe`);
+    (0, output_1.step)(`Iniciando ${projectName}.exe...`);
+    (0, execa_1.default)(exeOut, [], { detached: true, stdio: 'ignore' }).unref();
+}

package/dist/build/execute.js

@@ -0,0 +1,59 @@
+"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.executeBuild = executeBuild;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const output_1 = require("../ui/output");
+const compiler_1 = require("./compiler");
+const project_1 = require("./project");
+const resources_1 = require("./resources");
+async function executeBuild(opts) {
+    (0, output_1.banner)();
+    const { workspaceDir, projectName } = (0, project_1.resolveProject)(opts.project, opts.repoBase);
+    (0, output_1.printBuildHeader)(opts, projectName, workspaceDir);
+    (0, resources_1.prepareProjectResources)(opts, projectName, workspaceDir);
+    const oldRes = path.win32.join(workspaceDir, `${projectName}.res`);
+    if (fs.existsSync(oldRes))
+        fs.unlinkSync(oldRes);
+    const resFile = await (0, compiler_1.runCgrc)(opts, projectName);
+    fs.copyFileSync(resFile, path.win32.join(workspaceDir, `${projectName}.res`));
+    await (0, compiler_1.runDcc64)(opts, projectName, workspaceDir);
+    (0, output_1.printSuccess)(opts.type);
+    const { runAfter } = (0, compiler_1.buildCompilerFlags)(opts.type);
+    if (runAfter) {
+        (0, compiler_1.runBuiltExecutable)(opts, projectName);
+    }
+}

package/dist/build/project.js

@@ -0,0 +1,43 @@
+"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.resolveProject = resolveProject;
+const path = __importStar(require("path"));
+function resolveProject(projectPath, repoBase) {
+    const fullPath = path.win32.join(repoBase, projectPath);
+    const workspaceDir = path.win32.dirname(fullPath) + path.win32.sep;
+    const projectName = path.win32.basename(fullPath);
+    return { workspaceDir, projectName };
+}

package/dist/build/resources.js

@@ -0,0 +1,175 @@
+"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.prepareProjectResources = prepareProjectResources;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const output_1 = require("../ui/output");
+function parseVersionParts(version) {
+    const normalized = version.trim().replace(/\.+$/, '');
+    const parts = normalized.split('.');
+    return [
+        parts[0] ? Number(parts[0]) : 0,
+        parts[1] ? Number(parts[1]) : 0,
+        parts[2] ? Number(parts[2]) : 0,
+        parts[3] ? Number(parts[3]) : 0,
+    ];
+}
+function resolveVersionInfo(content, version) {
+    if (version && version.trim()) {
+        const [major, minor, release, build] = parseVersionParts(version);
+        const fullVersion = `${major}.${minor}.${release}.${build}`;
+        const nextContent = content
+            .replace(/(<VerInfo_MajorVer>)[^<]*(<\/VerInfo_MajorVer>)/, `$1${major}$2`)
+            .replace(/(<VerInfo_MinorVer>)[^<]*(<\/VerInfo_MinorVer>)/, `$1${minor}$2`)
+            .replace(/(<VerInfo_Release>)[^<]*(<\/VerInfo_Release>)/, `$1${release}$2`)
+            .replace(/(<VerInfo_Build>)[^<]*(<\/VerInfo_Build>)/, `$1${build}$2`)
+            .replace(/(FileVersion=)[^;<]*/g, `$1${fullVersion}`)
+            .replace(/(ProductVersion=)[^;<]*/g, `$1${fullVersion}`);
+        return { content: nextContent, fullVersion, parts: [major, minor, release, build] };
+    }
+    const major = Number(content.match(/<VerInfo_MajorVer>([^<]*)<\/VerInfo_MajorVer>/)?.[1] || 1);
+    const minor = Number(content.match(/<VerInfo_MinorVer>([^<]*)<\/VerInfo_MinorVer>/)?.[1] || 0);
+    const release = Number(content.match(/<VerInfo_Release>([^<]*)<\/VerInfo_Release>/)?.[1] || 0);
+    const build = Number(content.match(/<VerInfo_Build>([^<]*)<\/VerInfo_Build>/)?.[1] || 0);
+    const fullVersion = `${major}.${minor}.${release}.${build}`;
+    return { content, fullVersion, parts: [major, minor, release, build] };
+}
+function resolveMainIcon(content, delphiDir, projectDir, projectName) {
+    const iconPathRaw = (content.match(/<Icon_MainIcon>([^<]*)<\/Icon_MainIcon>/)?.[1] || '').trim();
+    let resolvedIconPath = iconPathRaw.replace(/\$\(BDS\)/g, delphiDir);
+    if (resolvedIconPath && !path.win32.isAbsolute(resolvedIconPath)) {
+        resolvedIconPath = path.win32.join(projectDir, resolvedIconPath);
+    }
+    const projectIcon = path.win32.join(projectDir, `${projectName}_Icon.ico`);
+    const fallbackIcon = path.win32.join(delphiDir, 'bin', 'delphi_PROJECTICON.ico');
+    if (resolvedIconPath && fs.existsSync(resolvedIconPath)) {
+        return resolvedIconPath;
+    }
+    if (fs.existsSync(projectIcon)) {
+        return projectIcon;
+    }
+    return fallbackIcon;
+}
+function buildManifestContent(projectName, fullVersion) {
+    return [
+        '<?xml version="1.0" encoding="UTF-8" standalone="yes"?>',
+        '<assembly xmlns="urn:schemas-microsoft-com:asm.v1" manifestVersion="1.0">',
+        `  <assemblyIdentity type="win32" name="${projectName}" version="${fullVersion}" processorArchitecture="*"/>`,
+        '  <dependency>',
+        '    <dependentAssembly>',
+        '      <assemblyIdentity type="win32" name="Microsoft.Windows.Common-Controls" version="6.0.0.0" publicKeyToken="6595b64144ccf1df" language="*" processorArchitecture="*"/>',
+        '    </dependentAssembly>',
+        '  </dependency>',
+        '  <trustInfo xmlns="urn:schemas-microsoft-com:asm.v3">',
+        '    <security>',
+        '      <requestedPrivileges>',
+        '        <requestedExecutionLevel level="asInvoker" uiAccess="false"/>',
+        '      </requestedPrivileges>',
+        '    </security>',
+        '  </trustInfo>',
+        '</assembly>',
+    ].join('\r\n');
+}
+function buildVrcContent(projectName, fullVersion, parts, manifestPath, iconPath) {
+    const [major, minor, release, build] = parts;
+    const lines = [];
+    if (iconPath) {
+        lines.push(`MAINICON ICON "${iconPath.replace(/\\/g, '\\\\')}"`);
+    }
+    lines.push(`1 24 "${manifestPath.replace(/\\/g, '\\\\')}"`);
+    lines.push('1 VERSIONINFO');
+    lines.push(`FILEVERSION ${major},${minor},${release},${build}`);
+    lines.push(`PRODUCTVERSION ${major},${minor},${release},${build}`);
+    lines.push('FILEFLAGSMASK 0x3FL');
+    lines.push('FILEFLAGS 0x00L');
+    lines.push('FILEOS 0x40004L');
+    lines.push('FILETYPE 0x1L');
+    lines.push('FILESUBTYPE 0x0L');
+    lines.push('BEGIN');
+    lines.push('    BLOCK "StringFileInfo"');
+    lines.push('    BEGIN');
+    lines.push('        BLOCK "040904E4"');
+    lines.push('        BEGIN');
+    lines.push('            VALUE "CompanyName", "\\0"');
+    lines.push(`            VALUE "FileDescription", "${projectName}\\0"`);
+    lines.push(`            VALUE "FileVersion", "${fullVersion}\\0"`);
+    lines.push('            VALUE "InternalName", "\\0"');
+    lines.push('            VALUE "LegalCopyright", "\\0"');
+    lines.push(`            VALUE "OriginalFilename", "${projectName}.exe\\0"`);
+    lines.push(`            VALUE "ProductName", "${projectName}\\0"`);
+    lines.push(`            VALUE "ProductVersion", "${fullVersion}\\0"`);
+    lines.push('        END');
+    lines.push('    END');
+    lines.push('    BLOCK "VarFileInfo"');
+    lines.push('    BEGIN');
+    lines.push('        VALUE "Translation", 0x0409, 1252');
+    lines.push('    END');
+    lines.push('END');
+    return lines.join('\r\n');
+}
+function prepareProjectResources(opts, projectName, workspaceDir) {
+    const dproj = path.win32.join(workspaceDir, `${projectName}.dproj`);
+    const tempDir = path.join(os.tmpdir(), `BimerBuild_${projectName}`);
+    const manifestFile = path.join(tempDir, `${projectName}.manifest`);
+    const vrcFile = path.join(tempDir, `${projectName}.vrc`);
+    if (!fs.existsSync(tempDir))
+        fs.mkdirSync(tempDir, { recursive: true });
+    if (!fs.existsSync(dproj)) {
+        (0, output_1.fatal)(`Arquivo de projeto não encontrado: ${dproj}`);
+    }
+    if (opts.version) {
+        (0, output_1.step)(`Injetando versão ${opts.version} no projeto...`);
+    }
+    else {
+        (0, output_1.step)('Nenhuma versão informada. Lendo atual do projeto...');
+    }
+    try {
+        const projectContent = fs.readFileSync(dproj, 'utf-8');
+        const { content: updatedContent, fullVersion, parts } = resolveVersionInfo(projectContent, opts.version);
+        if (updatedContent !== projectContent) {
+            fs.writeFileSync(dproj, updatedContent, 'utf-8');
+        }
+        const iconPath = resolveMainIcon(updatedContent, opts.delphiDir, workspaceDir, projectName);
+        const manifestContent = buildManifestContent(projectName, fullVersion);
+        const vrcContent = buildVrcContent(projectName, fullVersion, parts, manifestFile, iconPath);
+        fs.writeFileSync(manifestFile, manifestContent, 'ascii');
+        fs.writeFileSync(vrcFile, vrcContent, 'ascii');
+    }
+    catch {
+        (0, output_1.fatal)('Falha ao preparar versão, manifesto e recursos do projeto.');
+    }
+}

package/dist/cli/program.js

@@ -0,0 +1,96 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCli = runCli;
+const commander_1 = require("commander");
+const chalk_1 = __importDefault(require("chalk"));
+const execute_1 = require("../build/execute");
+const config_1 = require("../config/config");
+const output_1 = require("../ui/output");
+const prompts_1 = require("../ui/prompts");
+async function runCli(argv) {
+    const resolvedConfigPath = (0, config_1.resolveConfigPath)(argv);
+    const writableConfigPath = (0, config_1.getWritableConfigPath)(resolvedConfigPath);
+    const config = (0, config_1.loadConfig)(resolvedConfigPath);
+    const program = new commander_1.Command();
+    program
+        .name('delphi')
+        .description('CLI de build local para projetos Delphi do Bimer')
+        .version('1.0.0')
+        .option('-c, --config <path>', `Caminho do arquivo de configuração (ou ${config_1.CONFIG_ENV_VAR})`);
+    program
+        .command('build')
+        .description('Compila um projeto Delphi (interativo se flags omitidas)')
+        .option('-t, --type <FAST|DEBUG|RELEASE>', 'Modo de build')
+        .option('-p, --project <path>', 'Caminho do projeto (ex: faturamento\\BimerFaturamento)')
+        .option('-v, --version <version>', 'Versão a injetar (ex: 11.2.4)')
+        .action(async (opts) => {
+        const buildType = opts.type?.toUpperCase();
+        if (buildType && !['FAST', 'DEBUG', 'RELEASE'].includes(buildType)) {
+            (0, output_1.fatal)(`Tipo de build inválido: "${opts.type}". Use FAST, DEBUG ou RELEASE.`);
+        }
+        const resolved = await (0, prompts_1.promptBuild)(config, buildType, opts.project, opts.version);
+        await (0, execute_1.executeBuild)(resolved);
+    });
+    for (const type of ['fast', 'debug', 'release']) {
+        program
+            .command(type)
+            .description(`Compila no modo ${type.toUpperCase()} (interativo para projeto/versão)`)
+            .option('-p, --project <path>', 'Caminho do projeto')
+            .option('-v, --version <version>', 'Versão a injetar')
+            .action(async (opts) => {
+            const resolved = await (0, prompts_1.promptBuild)(config, type.toUpperCase(), opts.project, opts.version);
+            await (0, execute_1.executeBuild)(resolved);
+        });
+    }
+    const configCmd = program
+        .command('config')
+        .description('Gerencia a configuração do ambiente');
+    configCmd
+        .command('init')
+        .description('Configura o ambiente de forma interativa (cria bbuilder.config.json)')
+        .action(() => (0, prompts_1.runConfigInit)(config, writableConfigPath));
+    configCmd
+        .command('show')
+        .description('Exibe a configuração atual')
+        .action(() => {
+        console.log('');
+        console.log(chalk_1.default.cyan('  Configuração Atual'));
+        console.log(chalk_1.default.blue('  ──────────────────'));
+        console.log(chalk_1.default.gray(`  Arquivo: ${resolvedConfigPath}`));
+        console.log('');
+        console.log(JSON.stringify(config, null, 2)
+            .split('\n')
+            .map(line => '  ' + line)
+            .join('\n'));
+        console.log('');
+    });
+    const projectCmd = program
+        .command('project')
+        .description('Gerencia a lista de projetos');
+    projectCmd
+        .command('add')
+        .description('Adiciona um novo projeto à lista')
+        .action(() => (0, prompts_1.runProjectAdd)(config, writableConfigPath));
+    projectCmd
+        .command('list')
+        .description('Lista todos os projetos configurados')
+        .action(() => {
+        console.log('');
+        console.log(chalk_1.default.cyan('  Projetos Configurados'));
+        console.log(chalk_1.default.blue('  ─────────────────────'));
+        Object.entries(config.projects).forEach(([name, projectPath], index) => {
+            console.log(`  ${chalk_1.default.yellow(String(index + 1).padStart(2))}. ${chalk_1.default.white(name)} ${chalk_1.default.gray(`→ ${projectPath}`)}`);
+        });
+        console.log('');
+    });
+    if (argv.length <= 2) {
+        (0, output_1.banner)();
+        const resolved = await (0, prompts_1.promptBuild)(config);
+        await (0, execute_1.executeBuild)(resolved);
+        return;
+    }
+    await program.parseAsync(argv);
+}

package/dist/config/config.js

@@ -0,0 +1,184 @@
+"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.DEFAULT_CONFIG = exports.CONFIG_ENV_VAR = exports.LEGACY_CONFIG_FILENAME = exports.CONFIG_FILENAME = void 0;
+exports.buildDefaultDependencyPaths = buildDefaultDependencyPaths;
+exports.getDefaultConfigPath = getDefaultConfigPath;
+exports.getWritableConfigPath = getWritableConfigPath;
+exports.resolveConfigPath = resolveConfigPath;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+exports.CONFIG_FILENAME = 'bbuilder.config.json';
+exports.LEGACY_CONFIG_FILENAME = 'bimer.config.json';
+exports.CONFIG_ENV_VAR = 'BBUILDER_CONFIG';
+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',
+};
+function buildDefaultDependencyPaths(params) {
+    const { repoBase, delphiDir, libRoot, 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`,
+        `${libErp}\\Win64`,
+        `${libRoot}\\ZipForge\\Win64`,
+        `${libRoot}\\FortesReport\\Win64`,
+        `${libRoot}\\TBGWebCharts\\Win64`,
+        `${libRoot}\\EventBus\\Win64`,
+        `${libRoot}\\Horse\\Win64`,
+        `${libAlterdata}\\feedbacker`,
+        `${libAlterdata}\\rest-client`,
+    ];
+}
+exports.DEFAULT_CONFIG = {
+    ...DEFAULT_CONFIG_BASE,
+    dependencyPaths: buildDefaultDependencyPaths(DEFAULT_CONFIG_BASE),
+    projects: {
+        BimerFaturamento: 'faturamento\\BimerFaturamento',
+        Bimer: 'Bimer',
+        LiberadorEstoque: 'geral\\gerenteeletronico.jobs.liberadorestoque\\LiberadorEstoque',
+        BimerEstoque: 'estoque\\BimerEstoque',
+    },
+};
+function deriveProjectName(projectPath) {
+    const normalized = projectPath.replace(/[\\/]+$/, '');
+    const segments = normalized.split(/[\\/]/).filter(Boolean);
+    return segments[segments.length - 1] || projectPath;
+}
+function normalizeProjects(projects) {
+    if (projects && typeof projects === 'object' && !Array.isArray(projects)) {
+        return { ...projects };
+    }
+    if (Array.isArray(projects)) {
+        return projects.reduce((acc, projectPath) => {
+            if (typeof projectPath === 'string' && projectPath.trim()) {
+                acc[deriveProjectName(projectPath)] = projectPath;
+            }
+            return acc;
+        }, {});
+    }
+    return { ...exports.DEFAULT_CONFIG.projects };
+}
+function getUserConfigDirectory() {
+    if (process.platform === 'win32') {
+        const appData = process.env.APPDATA || path.join(os.homedir(), 'AppData', 'Roaming');
+        return path.join(appData, 'bbuilder-cli');
+    }
+    const xdgConfig = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+    return path.join(xdgConfig, 'bbuilder-cli');
+}
+function getDefaultConfigPath() {
+    return path.join(getUserConfigDirectory(), exports.CONFIG_FILENAME);
+}
+function getWritableConfigPath(configPath) {
+    if (path.basename(configPath) === exports.LEGACY_CONFIG_FILENAME) {
+        return path.join(path.dirname(configPath), exports.CONFIG_FILENAME);
+    }
+    return configPath;
+}
+function resolveConfigPath(argv = process.argv) {
+    for (let index = 0; index < argv.length; index++) {
+        const current = argv[index];
+        if (current === '--config' || current === '-c') {
+            const next = argv[index + 1];
+            if (next)
+                return path.resolve(next);
+        }
+        if (current.startsWith('--config=')) {
+            return path.resolve(current.slice('--config='.length));
+        }
+    }
+    const envPath = process.env[exports.CONFIG_ENV_VAR];
+    if (envPath) {
+        return path.resolve(envPath);
+    }
+    const localConfig = path.join(process.cwd(), exports.CONFIG_FILENAME);
+    if (fs.existsSync(localConfig)) {
+        return localConfig;
+    }
+    const legacyLocalConfig = path.join(process.cwd(), exports.LEGACY_CONFIG_FILENAME);
+    if (fs.existsSync(legacyLocalConfig)) {
+        return legacyLocalConfig;
+    }
+    return getDefaultConfigPath();
+}
+function loadConfig(configPath) {
+    if (fs.existsSync(configPath)) {
+        try {
+            const raw = fs.readFileSync(configPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            const merged = {
+                ...exports.DEFAULT_CONFIG,
+                ...parsed,
+                projects: normalizeProjects(parsed.projects),
+            };
+            if (!Array.isArray(parsed.dependencyPaths) || parsed.dependencyPaths.length === 0) {
+                merged.dependencyPaths = buildDefaultDependencyPaths(merged);
+            }
+            return merged;
+        }
+        catch {
+            // ignora parse error, usa default
+        }
+    }
+    return { ...exports.DEFAULT_CONFIG };
+}
+function saveConfig(config, configPath) {
+    fs.mkdirSync(path.dirname(configPath), { recursive: true });
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2), 'utf-8');
+}

package/dist/index.js

@@ -0,0 +1,12 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const program_1 = require("./cli/program");
+(0, program_1.runCli)(process.argv).catch(err => {
+    console.error(chalk_1.default.red('\n  [FATAL] ') + (err instanceof Error ? err.message : String(err)));
+    process.exit(1);
+});

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ui/output.js

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.banner = banner;
+exports.printBuildHeader = printBuildHeader;
+exports.printSuccess = printSuccess;
+exports.step = step;
+exports.fatal = fatal;
+const chalk_1 = __importDefault(require("chalk"));
+function banner() {
+    console.log('');
+    console.log(chalk_1.default.blue('  ══════════════════════════════════════════════════════════════'));
+    console.log(chalk_1.default.cyan('     ____  _                     ____        _ __    __        '));
+    console.log(chalk_1.default.cyan('    / __ )(_)___ ___  ___  _____/ __ )__  __(_) /___/ /        '));
+    console.log(chalk_1.default.cyan('   / __  / / __ `__ \\/ _ \\/ ___/ __  / / / / / / __  /         '));
+    console.log(chalk_1.default.cyan('  / /_/ / / / / / / /  __/ /  / /_/ / /_/ / / / /_/ /          '));
+    console.log(chalk_1.default.cyan(' /_____/_/_/ /_/ /_/\\___/_/  /_____/\\__,_/_/_/\\__,_/           '));
+    console.log(chalk_1.default.blue('  ──────────────────────────────────────────────────────────────'));
+    console.log(chalk_1.default.green('  [+]') + chalk_1.default.white(' Iniciando Pipeline DevOps Local...      ') + chalk_1.default.green('[ RUNNING ]'));
+    console.log(chalk_1.default.green('  [+]') + chalk_1.default.white(' Engatando Motor Embarcadero...          ') + chalk_1.default.green('[ STANDBY ]'));
+    console.log(chalk_1.default.green('  [+]') + chalk_1.default.white(' Sanitizando Caches Fantasmas...         ') + chalk_1.default.green('[ CLEARED ]'));
+    console.log(chalk_1.default.blue('  ══════════════════════════════════════════════════════════════'));
+    console.log('');
+}
+function printBuildHeader(opts, projectName, workspaceDir) {
+    const typeColor = {
+        FAST: chalk_1.default.yellow,
+        DEBUG: chalk_1.default.cyan,
+        RELEASE: chalk_1.default.green,
+    };
+    const col = typeColor[opts.type];
+    console.log(chalk_1.default.magenta('  [ PROJETO ]') + ' ' + chalk_1.default.white(projectName));
+    console.log(chalk_1.default.magenta('  [ CAMINHO ]') + ' ' + chalk_1.default.white(workspaceDir));
+    console.log(chalk_1.default.magenta('  [ VERSÃO  ]') + ' ' + chalk_1.default.yellow(opts.version || '(atual)') + ` (Base: ${opts.envVersion})`);
+    console.log(chalk_1.default.magenta('  [ PROFILE ]') + ' ' + col(opts.type));
+    console.log(chalk_1.default.blue('  ──────────────────────────────────────────────────────────────'));
+    console.log('');
+}
+function printSuccess(buildType) {
+    console.log('');
+    console.log(chalk_1.default.red('       .oooooo.         ') + chalk_1.default.green(' _____________________________________________'));
+    console.log(chalk_1.default.red('     .o00000000o.       ') + chalk_1.default.green('   _____ _    _  _____ _____ ______  _____ _____ '));
+    console.log(chalk_1.default.red('    .00') + chalk_1.default.white('######') + chalk_1.default.red('0000.      ') + chalk_1.default.green('  / ____| |  | |/ ____/ ____|  ____/ ____|/ ____|'));
+    console.log(chalk_1.default.red('    000') + chalk_1.default.white('##') + chalk_1.default.red('0000') + chalk_1.default.white('##') + chalk_1.default.red('000      ') + chalk_1.default.green(' | (___ | |  | | |   | |    | |__  \\___  \\___  |'));
+    console.log(chalk_1.default.red('    000') + chalk_1.default.white('##') + chalk_1.default.red('00000') + chalk_1.default.white('##') + chalk_1.default.red('00      ') + chalk_1.default.green('  \\___ \\| |  | | |   | |    |  __|  ___ \\  ___ |'));
+    console.log(chalk_1.default.red('    000') + chalk_1.default.white('##') + chalk_1.default.red('0000') + chalk_1.default.white('##') + chalk_1.default.red('000      ') + chalk_1.default.green('  ____) | |__| | |___| |____| |____ ____) |____) |'));
+    console.log(chalk_1.default.red("    `00") + chalk_1.default.white('######') + chalk_1.default.red("0000'      ") + chalk_1.default.green(' |_____/ \\____/ \\_____\\_____|______|_____/|_____/'));
+    console.log(chalk_1.default.red("     `o00000000o'       ") + chalk_1.default.green(' _____________________________________________'));
+    console.log(chalk_1.default.red("       `oooooo'         ") + chalk_1.default.cyan('  [*] ') + chalk_1.default.white('Build ') + chalk_1.default.yellow(buildType) + chalk_1.default.white(' finalizado com êxito absoluto!'));
+    console.log(chalk_1.default.red('                        ') + chalk_1.default.cyan('  [*] ') + chalk_1.default.white('Artefatos validados, versionados e linkados na raiz.'));
+    console.log(chalk_1.default.red('                        ') + chalk_1.default.green('  [ RUN ] O ecossistema está pronto para combate.'));
+    console.log(chalk_1.default.green('                        _____________________________________________'));
+    console.log('');
+}
+function step(msg) {
+    console.log(chalk_1.default.cyan('  [*]') + ' ' + chalk_1.default.white(msg));
+}
+function fatal(msg) {
+    console.error('');
+    console.error(chalk_1.default.red('  [ERRO FATAL] ') + msg);
+    console.error('');
+    process.exit(1);
+}

package/dist/ui/prompts.js

@@ -0,0 +1,124 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.promptBuild = promptBuild;
+exports.runConfigInit = runConfigInit;
+exports.runProjectAdd = runProjectAdd;
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const config_1 = require("../config/config");
+async function promptBuild(config, cliType, cliProject, cliVersion) {
+    const questions = [];
+    const projectChoices = Object.entries(config.projects).map(([name, projectPath]) => ({
+        name,
+        value: projectPath,
+    }));
+    if (!cliType) {
+        questions.push({
+            type: 'list',
+            name: 'type',
+            message: 'Modo de build:',
+            choices: [
+                { name: '⚡ FAST    — Rápido, sem full rebuild, abre o sistema', value: 'FAST' },
+                { name: '🔍 DEBUG   — Com símbolos de debug, abre o sistema', value: 'DEBUG' },
+                { name: '🚀 RELEASE — Otimizado, não abre o sistema', value: 'RELEASE' },
+            ],
+            default: 'DEBUG',
+        });
+    }
+    if (!cliProject) {
+        questions.push({
+            type: 'list',
+            name: 'project',
+            message: 'Qual projeto compilar?',
+            choices: projectChoices,
+            default: projectChoices[0]?.value,
+        });
+    }
+    if (!cliVersion) {
+        questions.push({
+            type: 'input',
+            name: 'version',
+            message: 'Versão do EXE? (deixe em branco para manter atual):',
+            default: '',
+        });
+    }
+    const answers = await inquirer_1.default.prompt(questions);
+    return {
+        type: (cliType || answers.type),
+        project: cliProject || answers.project,
+        version: cliVersion || answers.version || '',
+        repoBase: config.repoBase,
+        delphiDir: config.delphiDir,
+        envVersion: config.envVersion,
+        libRoot: config.libRoot,
+        libErp: config.libErp,
+        libAlterdata: config.libAlterdata,
+        dependencyPaths: config.dependencyPaths,
+    };
+}
+async function runConfigInit(config, configPath) {
+    console.log('');
+    console.log(chalk_1.default.cyan('  Configuração Interativa do Ambiente'));
+    console.log(chalk_1.default.blue('  ────────────────────────────────────'));
+    const answers = await inquirer_1.default.prompt([
+        { type: 'input', name: 'repoBase', message: 'Raiz do repositório:', default: config.repoBase },
+        { type: 'input', name: 'delphiDir', message: 'Diretório do Delphi:', default: config.delphiDir },
+        { 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 newConfig = {
+        ...config,
+        ...answers,
+        libErp,
+        libAlterdata: config.libAlterdata,
+        dependencyPaths: (0, config_1.buildDefaultDependencyPaths)({
+            repoBase: answers.repoBase,
+            delphiDir: answers.delphiDir,
+            libRoot: answers.libRoot,
+            libErp,
+            libAlterdata: config.libAlterdata,
+        }),
+    };
+    (0, config_1.saveConfig)(newConfig, configPath);
+    console.log('');
+    console.log(chalk_1.default.green('  ✔ bbuilder.config.json salvo com sucesso!'));
+    console.log(chalk_1.default.gray(`    ${configPath}`));
+    console.log('');
+}
+async function runProjectAdd(config, configPath) {
+    const { projectName, projectPath } = await inquirer_1.default.prompt([
+        {
+            type: 'input',
+            name: 'projectName',
+            message: 'Nome do projeto (ex: BimerFaturamento):',
+        },
+        {
+            type: 'input',
+            name: 'projectPath',
+            message: 'Caminho do projeto (ex: geral\\integrador\\IntegradorXPTO):',
+        },
+    ]);
+    if (!projectName || !projectPath)
+        return;
+    if (config.projects[projectName]) {
+        console.log(chalk_1.default.yellow('\n  Já existe um projeto com esse nome.\n'));
+        return;
+    }
+    if (Object.values(config.projects).includes(projectPath)) {
+        console.log(chalk_1.default.yellow('\n  Esse caminho de projeto já está cadastrado.\n'));
+        return;
+    }
+    const nextConfig = {
+        ...config,
+        projects: {
+            ...config.projects,
+            [projectName]: projectPath,
+        },
+    };
+    (0, config_1.saveConfig)(nextConfig, configPath);
+    console.log(chalk_1.default.green(`\n  ✔ Projeto "${projectName}" adicionado!\n`));
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@brunoluizdesiqueira/bbuilder-cli",
+  "version": "1.0.0",
+  "description": "CLI de build local para projetos Delphi do Bimer",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "bin": {
+    "delphi": "./dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node src/index.ts",
+    "prepack": "npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "chalk": "4.1.2",
+    "commander": "^12.0.0",
+    "execa": "5.1.1",
+    "inquirer": "^8.2.6"
+  },
+  "devDependencies": {
+    "@types/inquirer": "^8.2.10",
+    "@types/node": "^20.0.0",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.0"
+  }
+}