wlmaker 1.3.0 → 1.4.0

package/dist/cli.mjs

@@ -3,7 +3,7 @@
 // src/cli.ts
 import { createRequire } from "module";
 import { Command } from "commander";
-import chalk9 from "chalk";
+import chalk10 from "chalk";
 
 // src/core/create-bloc.ts
 import * as fs3 from "fs";
@@ -956,11 +956,12 @@ async function createUseCase(name, tierInput, options) {
 }
 
 // src/interactive.ts
-import * as fs13 from "fs";
+import * as fs14 from "fs";
 import * as os from "os";
-import * as path12 from "path";
+import * as path13 from "path";
+import { execSync as execSync2 } from "child_process";
 import * as clack from "@clack/prompts";
-import chalk8 from "chalk";
+import chalk9 from "chalk";
 
 // src/core/create-endpoint.ts
 import * as fs9 from "fs";
@@ -1049,8 +1050,8 @@ ${paramsClass}
 }
 `;
 }
-function retrofitMethod(methodName, path13, httpMethod, params, returnType) {
-  const httpAnnotation = `@${httpMethod.toUpperCase()}('${path13}')`;
+function retrofitMethod(methodName, path14, httpMethod, params, returnType) {
+  const httpAnnotation = `@${httpMethod.toUpperCase()}('${path14}')`;
   const paramList = params.map((p) => {
     if (p.isPath) return `@Path('${p.name}') ${p.type} ${p.name}`;
     if (p.isBody) return `@Body() ${p.type} ${p.name}`;
@@ -1211,15 +1212,15 @@ async function createEndpoint(options) {
   const methodParamsForSignature = methodParams.map((p) => ({ name: p.name, type: p.type }));
   const modelType = `${pascal}Model`;
   const entityType = `${pascal}Entity`;
-  const spinner2 = (msg) => console.log(chalk4.cyan(`  \u2192 ${msg}`));
-  spinner2("Generating entity");
+  const spinner3 = (msg) => console.log(chalk4.cyan(`  \u2192 ${msg}`));
+  spinner3("Generating entity");
   const entityDir = path8.join(lib, "domain", "entities", feature);
   fs9.mkdirSync(entityDir, { recursive: true });
   fs9.writeFileSync(
     path8.join(entityDir, `${useCaseSnake}_entity.dart`),
     entityBoilerplate(pascal)
   );
-  spinner2("Generating model");
+  spinner3("Generating model");
   const modelDir = path8.join(lib, "data", "models", feature);
   fs9.mkdirSync(modelDir, { recursive: true });
   fs9.writeFileSync(
@@ -1227,7 +1228,7 @@ async function createEndpoint(options) {
     modelBoilerplate(useCaseSnake, pascal, options.projectName)
   );
   if (needsBody) {
-    spinner2("Generating request model");
+    spinner3("Generating request model");
     const reqModelDir = path8.join(lib, "data", "models", feature);
     fs9.mkdirSync(reqModelDir, { recursive: true });
     fs9.writeFileSync(
@@ -1235,7 +1236,7 @@ async function createEndpoint(options) {
       requestModelBoilerplate(useCaseSnake, pascal)
     );
   }
-  spinner2("Injecting Retrofit method");
+  spinner3("Injecting Retrofit method");
   const bffPath = path8.resolve(options.bffApiFile);
   if (fs9.existsSync(bffPath)) {
     const retrofitParams = buildRetrofitParams(options, pathParams, needsBody);
@@ -1250,7 +1251,7 @@ async function createEndpoint(options) {
   } else {
     console.log(chalk4.yellow(`  \u26A0 BFF API file not found: ${bffPath}`));
   }
-  spinner2("Injecting datasource method");
+  spinner3("Injecting datasource method");
   const dsPath = path8.resolve(datasourceFile);
   if (fs9.existsSync(dsPath)) {
     const dsMethod = datasourceMethod(
@@ -1262,7 +1263,7 @@ async function createEndpoint(options) {
   } else {
     console.log(chalk4.yellow(`  \u26A0 Datasource file not found: ${dsPath}`));
   }
-  spinner2("Injecting repository interface method");
+  spinner3("Injecting repository interface method");
   const repoIfacePath = path8.resolve(repositoryInterfaceFile);
   if (fs9.existsSync(repoIfacePath)) {
     const ifaceMethod = repositoryInterfaceMethod(
@@ -1274,7 +1275,7 @@ async function createEndpoint(options) {
   } else {
     console.log(chalk4.yellow(`  \u26A0 Repository interface not found: ${repoIfacePath}`));
   }
-  spinner2("Injecting repository implementation method");
+  spinner3("Injecting repository implementation method");
   const repoImplPath = path8.resolve(repositoryImplFile);
   if (fs9.existsSync(repoImplPath)) {
     const dsVarName = camelCase2(datasourceClassName);
@@ -1289,7 +1290,7 @@ async function createEndpoint(options) {
   } else {
     console.log(chalk4.yellow(`  \u26A0 Repository implementation not found: ${repoImplPath}`));
   }
-  spinner2("Generating UseCase");
+  spinner3("Generating UseCase");
   const useCaseDir = path8.join(lib, "domain", "usecases", feature);
   fs9.mkdirSync(useCaseDir, { recursive: true });
   fs9.writeFileSync(
@@ -1303,7 +1304,7 @@ async function createEndpoint(options) {
       options.projectName
     )
   );
-  spinner2("Updating barrel files");
+  spinner3("Updating barrel files");
   const dsFileName = path8.basename(datasourceFile);
   injectExport(
     path8.join(lib, "data", "datasources", "datasources.dart"),
@@ -1331,7 +1332,7 @@ async function createEndpoint(options) {
     `export '${feature}/${feature}.dart';`
   );
   if (options.diTarget && options.diTarget !== "none") {
-    spinner2("Registering in DI modules");
+    spinner3("Registering in DI modules");
     const appBaseDir = findAppBasePackageDir(options.projectRoot, options.diTarget);
     if (appBaseDir) {
       const domainPascal = pascalCase4(domain);
@@ -1464,24 +1465,594 @@ function injectModuleRegistration(filePath, className, registrationCode, dedupKe
   fs9.writeFileSync(filePath, newContent);
 }
 
-// src/core/docs-serve.ts
-import { spawn as spawn2 } from "child_process";
+// src/core/create-env-var.ts
 import * as fs10 from "fs";
 import * as path9 from "path";
+import { execSync } from "child_process";
 import chalk5 from "chalk";
+import { camelCase as camelCase3 } from "change-case";
+function screamingSnakeToCamel(name) {
+  return camelCase3(name.toLowerCase());
+}
+function dartTypeForGetter(type) {
+  return type;
+}
+function typedJsonValue(defaultValue, dartType) {
+  if (!defaultValue || !defaultValue.trim()) {
+    switch (dartType) {
+      case "int":
+        return 0;
+      case "bool":
+        return false;
+      case "List<String>":
+        return [];
+      default:
+        return "";
+    }
+  }
+  switch (dartType) {
+    case "int":
+      return parseInt(defaultValue, 10);
+    case "bool":
+      return defaultValue === "true";
+    case "List<String>":
+      return defaultValue.split(",").map((s) => s.trim());
+    default:
+      return defaultValue;
+  }
+}
+function abstractGetterCode(camelName, dartType) {
+  const type = dartTypeForGetter(dartType);
+  return `${type} get ${camelName};`;
+}
+function buildEnvGetterCode(camelName, constName, dartType) {
+  const type = dartTypeForGetter(dartType);
+  switch (dartType) {
+    case "String":
+      return `@override
+String get ${camelName} => const String.fromEnvironment('${constName}');`;
+    case "int":
+      return `@override
+int get ${camelName} => const int.fromEnvironment('${constName}');`;
+    case "bool":
+      return `@override
+bool get ${camelName} => const bool.fromEnvironment('${constName}');`;
+    case "List<String>":
+      return [
+        "@override",
+        `List<String> get ${camelName} {`,
+        `  const rawString = String.fromEnvironment('${constName}');`,
+        "  if (rawString.isEmpty) return [];",
+        "  return rawString.split(',').map((e) => e.trim()).toList();",
+        "}"
+      ].join("\n");
+  }
+}
+function appConfigDefaultValue(dartType) {
+  switch (dartType) {
+    case "String":
+      return "''";
+    case "int":
+      return "0";
+    case "bool":
+      return "false";
+    case "List<String>":
+      return "const []";
+  }
+}
+function appConfigModelJsonKey(camelName, dartType) {
+  switch (dartType) {
+    case "bool":
+      return `@override
+  @JsonKey(name: '${camelName}', fromJson: AppConfigModel.parseBool)`;
+    case "int":
+      return `@override
+  @JsonKey(name: '${camelName}', fromJson: AppConfigModel.parseInt)`;
+    case "List<String>":
+      return `@override
+  @JsonKey(name: '${camelName}', fromJson: AppConfigModel.parseToList)`;
+    default:
+      return `@override
+  @JsonKey(name: '${camelName}')`;
+  }
+}
+function discoverAppsWithEnv(monorepoRoot) {
+  const appsDir = path9.join(monorepoRoot, "apps");
+  if (!fs10.existsSync(appsDir)) return [];
+  return fs10.readdirSync(appsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).filter((d) => fs10.existsSync(path9.join(appsDir, d.name, "env"))).map((d) => d.name).sort();
+}
+function injectIntoJsonFile(filePath, key, value, isTemplate) {
+  if (!fs10.existsSync(filePath)) {
+    console.log(chalk5.yellow(`  Skipping ${filePath} (not found)`));
+    return;
+  }
+  const content = fs10.readFileSync(filePath, "utf8");
+  const json = JSON.parse(content);
+  if (key in json) {
+    console.log(chalk5.yellow(`  Key "${key}" already exists in ${path9.basename(filePath)}`));
+    return;
+  }
+  json[key] = isTemplate ? `\${${key}}` : value;
+  fs10.writeFileSync(filePath, JSON.stringify(json, null, 2) + "\n");
+  console.log(chalk5.green(`  Updated ${path9.basename(filePath)}`));
+}
+function injectAbstractGetter(monorepoRoot, camelName, dartType) {
+  const packagesDir = path9.join(monorepoRoot, "packages");
+  if (!fs10.existsSync(packagesDir)) return;
+  const envFile = findFileInPackages(packagesDir, "app_environment.dart");
+  if (!envFile) {
+    console.log(chalk5.yellow("  app_environment.dart not found in any package"));
+    return;
+  }
+  const content = fs10.readFileSync(envFile, "utf8");
+  const dedup = `get ${camelName}`;
+  if (content.includes(dedup)) {
+    console.log(chalk5.yellow(`  '${camelName}' already in AppEnvironment`));
+    return;
+  }
+  const getterRegex = /\n\s+\w+(?:<[^>]+>)?\s+get\s+\w+;/g;
+  let lastGetterMatch = null;
+  let match;
+  while ((match = getterRegex.exec(content)) !== null) {
+    lastGetterMatch = match;
+  }
+  if (!lastGetterMatch) {
+    console.log(chalk5.yellow("  No getters found in AppEnvironment"));
+    return;
+  }
+  const insertPos = lastGetterMatch.index + lastGetterMatch[0].length;
+  const getterLine = `
+  ${abstractGetterCode(camelName, dartType)}`;
+  const newContent = content.slice(0, insertPos) + getterLine + content.slice(insertPos);
+  fs10.writeFileSync(envFile, newContent);
+  console.log(chalk5.green(`  Injected abstract getter in ${formatPkgPath(monorepoRoot, envFile)}`));
+}
+function injectBuildEnvGetter(monorepoRoot, variableName, camelName, dartType) {
+  const packagesDir = path9.join(monorepoRoot, "packages");
+  if (!fs10.existsSync(packagesDir)) return;
+  const buildEnvFile = findFileInPackages(packagesDir, "app_build_environment.dart");
+  if (!buildEnvFile) {
+    console.log(chalk5.yellow("  app_build_environment.dart not found in any package"));
+    return;
+  }
+  const code = buildEnvGetterCode(camelName, variableName, dartType);
+  try {
+    injectMethod(buildEnvFile, "AppBuildEnvironment", code, `get ${camelName}`);
+    console.log(chalk5.green(`  Injected build env getter in ${formatPkgPath(monorepoRoot, buildEnvFile)}`));
+  } catch (e) {
+    console.log(chalk5.yellow(`  Skipped: ${e.message}`));
+  }
+}
+function injectIntoRemoteConfigDefaults(vendorsPath, camelName, dartType) {
+  const content = fs10.readFileSync(vendorsPath, "utf8");
+  if (content.includes(`'${camelName}'`) || content.includes(`"${camelName}"`)) {
+    console.log(chalk5.yellow(`  '${camelName}' already in ${path9.basename(vendorsPath)}`));
+    return;
+  }
+  const defaultValuesRegex = /final\s+defaultValues\s*=\s*(?:<String,\s*dynamic>\s*)?\{/;
+  const match = content.match(defaultValuesRegex);
+  if (!match) {
+    console.log(chalk5.yellow(`  Could not find defaultValues map in ${path9.basename(vendorsPath)}`));
+    return;
+  }
+  const mapStart = content.indexOf(match[0]) + match[0].length;
+  let braceCount = 1;
+  let mapEnd = -1;
+  for (let i = mapStart; i < content.length; i++) {
+    if (content[i] === "{") braceCount++;
+    else if (content[i] === "}") {
+      braceCount--;
+      if (braceCount === 0) {
+        mapEnd = i;
+        break;
+      }
+    }
+  }
+  if (mapEnd === -1) {
+    console.log(chalk5.yellow(`  Could not find end of defaultValues map`));
+    return;
+  }
+  const valueExpr = dartType === "List<String>" ? `jsonEncode(env.${camelName})` : `env.${camelName}`;
+  const beforeClose = content.slice(0, mapEnd);
+  const mapLines = beforeClose.split("\n");
+  let lastEntryIndent = "      ";
+  for (let i = mapLines.length - 1; i >= 0; i--) {
+    const trimmed = mapLines[i].trim();
+    if (trimmed.startsWith("'") || trimmed.startsWith('"')) {
+      const leadingSpaces = mapLines[i].match(/^(\s*)/)?.[1] ?? "";
+      lastEntryIndent = leadingSpaces;
+      break;
+    }
+  }
+  const insertion = `${lastEntryIndent}'${camelName}': ${valueExpr},
+`;
+  const newContent = content.slice(0, mapEnd) + insertion + content.slice(mapEnd);
+  fs10.writeFileSync(vendorsPath, newContent);
+  console.log(chalk5.green(`  Injected into VendorsModule defaultValues`));
+}
+function injectAppConfigProperty(configPath, camelName, dartType) {
+  const content = fs10.readFileSync(configPath, "utf8");
+  if (content.includes(`final ${dartTypeForGetter(dartType)} ${camelName}`)) {
+    console.log(chalk5.yellow(`  '${camelName}' already in AppConfig`));
+    return;
+  }
+  const fieldLine = `  final ${dartTypeForGetter(dartType)} ${camelName};
+`;
+  let newContent = content;
+  const propsMatch = newContent.match(/@override\n\s+List<Object\?>/);
+  if (propsMatch) {
+    const propsPos = newContent.indexOf(propsMatch[0]);
+    newContent = newContent.slice(0, propsPos) + fieldLine + newContent.slice(propsPos);
+  } else {
+    newContent = injectBeforeClassClose(newContent, "AppConfig", `  final ${dartTypeForGetter(dartType)} ${camelName};`);
+  }
+  newContent = injectConstructorParam(newContent, "AppConfig", camelName, dartType);
+  newContent = injectIntoPropsList(newContent, camelName);
+  fs10.writeFileSync(configPath, newContent);
+  console.log(chalk5.green(`  Injected into AppConfig entity`));
+}
+function injectAppConfigModelProperty(modelPath, camelName, dartType) {
+  const content = fs10.readFileSync(modelPath, "utf8");
+  if (content.includes(`final ${dartTypeForGetter(dartType)} ${camelName}`)) {
+    console.log(chalk5.yellow(`  '${camelName}' already in AppConfigModel`));
+    return;
+  }
+  const jsonKey = appConfigModelJsonKey(camelName, dartType);
+  const fieldLines = jsonKey ? `  ${jsonKey}
+  final ${dartTypeForGetter(dartType)} ${camelName};
+` : `  final ${dartTypeForGetter(dartType)} ${camelName};
+`;
+  let newContent = content;
+  const staticPos = newContent.search(/\n\s+static\s/);
+  const factoryPos = newContent.search(/\n\s+factory\s+AppConfigModel/);
+  let insertAnchor = -1;
+  if (staticPos !== -1 && factoryPos !== -1) {
+    insertAnchor = Math.min(staticPos, factoryPos);
+  } else if (staticPos !== -1) {
+    insertAnchor = staticPos;
+  } else if (factoryPos !== -1) {
+    insertAnchor = factoryPos;
+  }
+  if (insertAnchor !== -1) {
+    newContent = newContent.slice(0, insertAnchor + 1) + fieldLines + newContent.slice(insertAnchor + 1);
+  } else {
+    newContent = injectBeforeClassClose(newContent, "AppConfigModel", fieldLines);
+  }
+  newContent = injectConstructorParam(newContent, "AppConfigModel", camelName, dartType);
+  newContent = injectIntoSuperCall(newContent, camelName);
+  fs10.writeFileSync(modelPath, newContent);
+  console.log(chalk5.green(`  Injected into AppConfigModel`));
+}
+function injectBeforeClassClose(content, className, line) {
+  const classRegex = new RegExp(`class\\s+${className}\\s*[^{]*\\{`);
+  const classMatch = content.match(classRegex);
+  if (!classMatch) {
+    throw new Error(`Class "${className}" not found`);
+  }
+  const classStart = content.indexOf(classMatch[0]);
+  let braceCount = 0;
+  let classEnd = -1;
+  let foundOpen = false;
+  for (let i = classStart; i < content.length; i++) {
+    if (content[i] === "{") {
+      braceCount++;
+      foundOpen = true;
+    } else if (content[i] === "}") {
+      braceCount--;
+      if (foundOpen && braceCount === 0) {
+        classEnd = i;
+        break;
+      }
+    }
+  }
+  if (classEnd === -1) {
+    throw new Error(`Could not find closing brace for class "${className}"`);
+  }
+  return content.slice(0, classEnd) + line + "\n" + content.slice(classEnd);
+}
+function injectConstructorParam(content, className, camelName, dartType) {
+  const classRegex = new RegExp(`class\\s+${className}\\s*[^{]*\\{`);
+  const classMatch = content.match(classRegex);
+  if (!classMatch) return content;
+  const classStart = content.indexOf(classMatch[0]);
+  const constructorPattern = new RegExp(
+    `(?:const\\s+)?${className}\\s*\\(`
+  );
+  const searchFrom = classStart;
+  const constructorMatch = content.slice(searchFrom).match(constructorPattern);
+  if (!constructorMatch) return content;
+  const constructorAbsStart = searchFrom + constructorMatch.index;
+  const parenStart = content.indexOf("(", constructorAbsStart);
+  const afterParen = content.slice(parenStart + 1).trimStart();
+  if (afterParen.startsWith("{")) {
+    const braceOffset = content.slice(parenStart + 1).indexOf("{");
+    const braceStart = parenStart + 1 + braceOffset;
+    let braceCount = 1;
+    let braceEnd = -1;
+    for (let i = braceStart + 1; i < content.length; i++) {
+      if (content[i] === "{") braceCount++;
+      else if (content[i] === "}") {
+        braceCount--;
+        if (braceCount === 0) {
+          braceEnd = i;
+          break;
+        }
+      }
+    }
+    if (braceEnd === -1) return content;
+    const beforeClose = content.slice(0, braceEnd);
+    const paramLines = beforeClose.split("\n");
+    let lastParamIndent = "    ";
+    for (let i = paramLines.length - 1; i >= 0; i--) {
+      const trimmed = paramLines[i].trim();
+      if (trimmed.startsWith("this.") || trimmed.startsWith("required")) {
+        const leadingSpaces = paramLines[i].match(/^(\s*)/)?.[1] ?? "";
+        lastParamIndent = leadingSpaces;
+        break;
+      }
+    }
+    const defaultVal = appConfigDefaultValue(dartType);
+    const insertion = `${lastParamIndent}this.${camelName} = ${defaultVal},
+`;
+    return content.slice(0, braceEnd) + insertion + content.slice(braceEnd);
+  } else {
+    let parenCount = 1;
+    let parenEnd = -1;
+    for (let i = parenStart + 1; i < content.length; i++) {
+      if (content[i] === "(") parenCount++;
+      else if (content[i] === ")") {
+        parenCount--;
+        if (parenCount === 0) {
+          parenEnd = i;
+          break;
+        }
+      }
+    }
+    if (parenEnd === -1) return content;
+    const beforeClose = content.slice(0, parenEnd);
+    const paramLines = beforeClose.split("\n");
+    let lastParamIndent = "    ";
+    for (let i = paramLines.length - 1; i >= 0; i--) {
+      const trimmed = paramLines[i].trim();
+      if (trimmed.length > 0) {
+        const leadingSpaces = paramLines[i].match(/^(\s*)/)?.[1] ?? "";
+        lastParamIndent = leadingSpaces;
+        break;
+      }
+    }
+    const defaultVal = appConfigDefaultValue(dartType);
+    const insertion = `${lastParamIndent}this.${camelName} = ${defaultVal},
+`;
+    return content.slice(0, parenEnd) + insertion + content.slice(parenEnd);
+  }
+}
+function injectIntoPropsList(content, camelName) {
+  const propsRegex = /List<Object\?>\s+get\s+props\s*=>\s*\[/;
+  const match = content.match(propsRegex);
+  if (!match) return content;
+  const propsStart = content.indexOf(match[0]) + match[0].length;
+  let bracketCount = 1;
+  let bracketEnd = -1;
+  for (let i = propsStart; i < content.length; i++) {
+    if (content[i] === "[") bracketCount++;
+    else if (content[i] === "]") {
+      bracketCount--;
+      if (bracketCount === 0) {
+        bracketEnd = i;
+        break;
+      }
+    }
+  }
+  if (bracketEnd === -1) return content;
+  const beforeClose = content.slice(0, bracketEnd);
+  const propLines = beforeClose.split("\n");
+  let lastPropIndent = "    ";
+  for (let i = propLines.length - 1; i >= 0; i--) {
+    const trimmed = propLines[i].trim();
+    if (trimmed.length > 0 && trimmed !== "[") {
+      const leadingSpaces = propLines[i].match(/^(\s*)/)?.[1] ?? "";
+      lastPropIndent = leadingSpaces;
+      break;
+    }
+  }
+  const insertion = `${lastPropIndent}${camelName},
+`;
+  return content.slice(0, bracketEnd) + insertion + content.slice(bracketEnd);
+}
+function injectIntoSuperCall(content, camelName) {
+  const superRegex = /super\s*\(\s*/;
+  const match = content.match(superRegex);
+  if (!match) return content;
+  const superStart = content.indexOf(match[0]) + match[0].length;
+  let parenCount = 1;
+  let parenEnd = -1;
+  for (let i = superStart; i < content.length; i++) {
+    if (content[i] === "(") parenCount++;
+    else if (content[i] === ")") {
+      parenCount--;
+      if (parenCount === 0) {
+        parenEnd = i;
+        break;
+      }
+    }
+  }
+  if (parenEnd === -1) return content;
+  const beforeClose = content.slice(0, parenEnd);
+  const superLines = beforeClose.split("\n");
+  let lastEntryIndent = "         ";
+  for (let i = superLines.length - 1; i >= 0; i--) {
+    const trimmed = superLines[i].trim();
+    if (trimmed.length > 0 && trimmed.includes(":")) {
+      const leadingSpaces = superLines[i].match(/^(\s*)/)?.[1] ?? "";
+      lastEntryIndent = leadingSpaces;
+      break;
+    }
+  }
+  const insertion = `${lastEntryIndent}${camelName}: ${camelName},
+`;
+  return content.slice(0, parenEnd) + insertion + content.slice(parenEnd);
+}
+function findFileRecursive(dir, fileName) {
+  const entries = fs10.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path9.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const result = findFileRecursive(fullPath, fileName);
+      if (result) return result;
+    } else if (entry.name === fileName) {
+      return fullPath;
+    }
+  }
+  return null;
+}
+function discoverVendorsModules(monorepoRoot) {
+  const packagesDir = path9.join(monorepoRoot, "packages");
+  if (!fs10.existsSync(packagesDir)) return [];
+  const results = [];
+  const packages = fs10.readdirSync(packagesDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+  for (const pkg2 of packages) {
+    const pkgDir = path9.join(packagesDir, pkg2.name);
+    const found = findFileRecursive(pkgDir, "vendors_module.dart");
+    if (found) results.push(pkg2.name);
+  }
+  return results.sort();
+}
+function findAppConfigFile(monorepoRoot) {
+  const packagesDir = path9.join(monorepoRoot, "packages");
+  if (!fs10.existsSync(packagesDir)) return null;
+  return findClassInPackages(packagesDir, "AppConfig");
+}
+function findAppConfigModelFile(monorepoRoot) {
+  const packagesDir = path9.join(monorepoRoot, "packages");
+  if (!fs10.existsSync(packagesDir)) return null;
+  return findClassInPackages(packagesDir, "AppConfigModel");
+}
+function findClassInPackages(packagesDir, className) {
+  const packages = fs10.readdirSync(packagesDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => path9.join(packagesDir, d.name));
+  for (const pkgDir of packages) {
+    const found = findClassFileRecursive(pkgDir, className);
+    if (found) return found;
+  }
+  return null;
+}
+function findClassFileRecursive(dir, className) {
+  const classRegex = new RegExp(`\\bclass\\s+${className}\\b`);
+  const entries = fs10.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path9.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      const result = findClassFileRecursive(fullPath, className);
+      if (result) return result;
+    } else if (entry.name.endsWith(".dart") && !entry.name.endsWith(".g.dart")) {
+      const content = fs10.readFileSync(fullPath, "utf8");
+      if (classRegex.test(content)) {
+        return fullPath;
+      }
+    }
+  }
+  return null;
+}
+function findFileInPackages(packagesDir, fileName) {
+  const packages = fs10.readdirSync(packagesDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => path9.join(packagesDir, d.name));
+  for (const pkgDir of packages) {
+    const found = findFileRecursive(pkgDir, fileName);
+    if (found) return found;
+  }
+  return null;
+}
+function formatPkgPath(monorepoRoot, absPath) {
+  return path9.relative(monorepoRoot, absPath);
+}
+var spinner = (msg) => console.log(chalk5.cyan(` \u2192 ${msg}`));
+async function createEnvVar(options) {
+  const {
+    monorepoRoot,
+    variableName,
+    dartType,
+    defaultValue,
+    selectedApps,
+    includeInRemoteConfig,
+    includeInAppConfig
+  } = options;
+  const camelName = screamingSnakeToCamel(variableName);
+  console.log(chalk5.bold(`
+Adding environment variable: ${chalk5.cyan(variableName)}
+`));
+  spinner("PASO 1: Updating env JSON files");
+  const jsonValue = typedJsonValue(defaultValue, dartType);
+  const appsDir = path9.join(monorepoRoot, "apps");
+  for (const app of selectedApps) {
+    const appEnvDir = path9.join(appsDir, app, "env");
+    const files = [
+      { name: "example.env.json", isTemplate: true },
+      { name: "development.env.json", isTemplate: false },
+      { name: "production.env.json", isTemplate: false }
+    ];
+    for (const { name, isTemplate } of files) {
+      injectIntoJsonFile(path9.join(appEnvDir, name), variableName, jsonValue, isTemplate);
+    }
+  }
+  spinner("PASO 2: Injecting into AppEnvironment");
+  injectAbstractGetter(monorepoRoot, camelName, dartType);
+  spinner("PASO 3: Injecting into AppBuildEnvironment");
+  injectBuildEnvGetter(monorepoRoot, variableName, camelName, dartType);
+  if (includeInRemoteConfig) {
+    spinner("PASO 4: Injecting into VendorsModule RemoteConfig");
+    for (const pkgName of options.vendorsTargets) {
+      const pkgDir = path9.join(monorepoRoot, "packages", pkgName);
+      const vendorsPath = findFileRecursive(pkgDir, "vendors_module.dart");
+      if (vendorsPath) {
+        console.log(chalk5.cyan(`  \u2192 ${pkgName}/vendors_module.dart`));
+        injectIntoRemoteConfigDefaults(vendorsPath, camelName, dartType);
+      } else {
+        console.log(chalk5.yellow(`  vendors_module.dart not found in ${pkgName}`));
+      }
+    }
+  }
+  if (includeInAppConfig) {
+    spinner("PASO 5: Injecting into AppConfig entity");
+    const configPath = findAppConfigFile(monorepoRoot);
+    if (configPath) {
+      injectAppConfigProperty(configPath, camelName, dartType);
+    } else {
+      console.log(chalk5.yellow("  app_config.dart not found, skipping AppConfig"));
+    }
+    spinner("PASO 6: Injecting into AppConfigModel");
+    const modelPath = findAppConfigModelFile(monorepoRoot);
+    if (modelPath) {
+      injectAppConfigModelProperty(modelPath, camelName, dartType);
+    } else {
+      console.log(chalk5.yellow("  app_config_model.dart not found, skipping AppConfigModel"));
+    }
+  }
+  console.log(chalk5.green("\nEnvironment variable added successfully!"));
+  spinner("Running melos format...");
+  try {
+    execSync("melos format", { cwd: monorepoRoot, stdio: "pipe" });
+    console.log(chalk5.green("  melos format completed"));
+  } catch {
+    console.log(chalk5.yellow("  melos format failed (you may need to run it manually)"));
+  }
+}
+
+// src/core/docs-serve.ts
+import { spawn as spawn2 } from "child_process";
+import * as fs11 from "fs";
+import * as path10 from "path";
+import chalk6 from "chalk";
 function detectBookDir(startDir) {
   const root = findMonorepoRoot(startDir) ?? startDir;
-  const bookDir = path9.join(root, "book");
-  if (fs10.existsSync(bookDir) && (fs10.existsSync(path9.join(bookDir, "docusaurus.config.js")) || fs10.existsSync(path9.join(bookDir, "docusaurus.config.ts")) || fs10.existsSync(path9.join(bookDir, "docusaurus.config.mjs")))) {
+  const bookDir = path10.join(root, "book");
+  if (fs11.existsSync(bookDir) && (fs11.existsSync(path10.join(bookDir, "docusaurus.config.js")) || fs11.existsSync(path10.join(bookDir, "docusaurus.config.ts")) || fs11.existsSync(path10.join(bookDir, "docusaurus.config.mjs")))) {
     return bookDir;
   }
   return void 0;
 }
 function serveBook(bookDir) {
   return new Promise((resolve4, reject) => {
-    const nodeModules = path9.join(bookDir, "node_modules");
-    if (!fs10.existsSync(nodeModules)) {
-      console.log(chalk5.cyan("Installing book dependencies..."));
+    const nodeModules = path10.join(bookDir, "node_modules");
+    if (!fs11.existsSync(nodeModules)) {
+      console.log(chalk6.cyan("Installing book dependencies..."));
       const install = spawn2("npm", ["install"], {
         cwd: bookDir,
         stdio: "inherit"
@@ -1515,16 +2086,16 @@ function startDevServer(bookDir, done) {
 }
 
 // src/core/docs-commands.ts
-import * as fs11 from "fs";
-import * as path10 from "path";
-import chalk6 from "chalk";
+import * as fs12 from "fs";
+import * as path11 from "path";
+import chalk7 from "chalk";
 import YAML2 from "yaml";
 function parseMakefile(filePath) {
-  if (!fs11.existsSync(filePath)) return [];
-  const content = fs11.readFileSync(filePath, "utf8");
+  if (!fs12.existsSync(filePath)) return [];
+  const content = fs12.readFileSync(filePath, "utf8");
   const lines = content.split("\n");
   const commands = [];
-  const source = path10.basename(filePath);
+  const source = path11.basename(filePath);
   let pendingComments = [];
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
@@ -1554,13 +2125,13 @@ function parseMakefile(filePath) {
   return commands;
 }
 function parseMelosScripts(filePath) {
-  if (!fs11.existsSync(filePath)) return [];
-  const content = fs11.readFileSync(filePath, "utf8");
+  if (!fs12.existsSync(filePath)) return [];
+  const content = fs12.readFileSync(filePath, "utf8");
   const parsed = YAML2.parse(content);
   const scripts = parsed?.scripts;
   if (!scripts || typeof scripts !== "object") return [];
   const commands = [];
-  const source = path10.basename(filePath);
+  const source = path11.basename(filePath);
   for (const [name, value] of Object.entries(scripts)) {
     let description = "";
     let command = "";
@@ -1582,17 +2153,17 @@ function parseMelosScripts(filePath) {
 function discoverCommands(startDir) {
   const root = findMonorepoRoot(startDir) ?? startDir;
   const commands = [];
-  const rootMakefile = path10.join(root, "Makefile");
+  const rootMakefile = path11.join(root, "Makefile");
   commands.push(...parseMakefile(rootMakefile));
-  const melosFile = path10.join(root, "melos.yaml");
+  const melosFile = path11.join(root, "melos.yaml");
   commands.push(...parseMelosScripts(melosFile));
-  const bookMakefile = path10.join(root, "book", "Makefile");
+  const bookMakefile = path11.join(root, "book", "Makefile");
   commands.push(...parseMakefile(bookMakefile));
   return commands;
 }
 function displayCommands(commands) {
   if (commands.length === 0) {
-    console.log(chalk6.yellow("No commands found."));
+    console.log(chalk7.yellow("No commands found."));
     return;
   }
   const groups = /* @__PURE__ */ new Map();
@@ -1602,13 +2173,13 @@ function displayCommands(commands) {
     groups.get(key).push(cmd);
   }
   for (const [group, entries] of groups) {
-    console.log(chalk6.bold(chalk6.cyan(`
+    console.log(chalk7.bold(chalk7.cyan(`
 ${group}`)));
-    console.log(chalk6.cyan("\u2500".repeat(group.length)));
+    console.log(chalk7.cyan("\u2500".repeat(group.length)));
     const maxNameLen = Math.max(...entries.map((e) => e.name.length));
     for (const entry of entries) {
-      const name = chalk6.white(entry.name.padEnd(maxNameLen + 2));
-      const desc = entry.description ? chalk6.gray(entry.description) : chalk6.dim("(no description)");
+      const name = chalk7.white(entry.name.padEnd(maxNameLen + 2));
+      const desc = entry.description ? chalk7.gray(entry.description) : chalk7.dim("(no description)");
       console.log(`  ${name} ${desc}`);
     }
   }
@@ -1616,9 +2187,9 @@ ${group}`)));
 }
 
 // src/core/docs-architecture.ts
-import * as fs12 from "fs";
-import * as path11 from "path";
-import chalk7 from "chalk";
+import * as fs13 from "fs";
+import * as path12 from "path";
+import chalk8 from "chalk";
 import YAML3 from "yaml";
 var KEY_DEPS = [
   "freezed",
@@ -1636,18 +2207,18 @@ var KEY_DEPS = [
 function discoverArchitecture(startDir) {
   const root = findMonorepoRoot(startDir);
   if (!root) return null;
-  const melosPath = path11.join(root, "melos.yaml");
-  if (!fs12.existsSync(melosPath)) return null;
-  const melosContent = fs12.readFileSync(melosPath, "utf8");
+  const melosPath = path12.join(root, "melos.yaml");
+  if (!fs13.existsSync(melosPath)) return null;
+  const melosContent = fs13.readFileSync(melosPath, "utf8");
   const melos = YAML3.parse(melosContent);
-  const projectName = melos?.name ?? path11.basename(root);
+  const projectName = melos?.name ?? path12.basename(root);
   const apps = [];
-  const appsDir = path11.join(root, "apps");
-  if (fs12.existsSync(appsDir)) {
-    for (const entry of fs12.readdirSync(appsDir, { withFileTypes: true })) {
+  const appsDir = path12.join(root, "apps");
+  if (fs13.existsSync(appsDir)) {
+    for (const entry of fs13.readdirSync(appsDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      const candidate = path11.join(appsDir, entry.name);
-      if (fs12.existsSync(path11.join(candidate, "pubspec.yaml"))) {
+      const candidate = path12.join(appsDir, entry.name);
+      if (fs13.existsSync(path12.join(candidate, "pubspec.yaml"))) {
         apps.push({ name: entry.name, dir: candidate });
       }
     }
@@ -1655,14 +2226,14 @@ function discoverArchitecture(startDir) {
   const packages = [];
   const packageBases = ["packages", "packages/features"];
   for (const base of packageBases) {
-    const baseDir = path11.join(root, base);
-    if (!fs12.existsSync(baseDir)) continue;
-    for (const entry of fs12.readdirSync(baseDir, { withFileTypes: true })) {
+    const baseDir = path12.join(root, base);
+    if (!fs13.existsSync(baseDir)) continue;
+    for (const entry of fs13.readdirSync(baseDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      const candidate = path11.join(baseDir, entry.name);
-      const pubspecPath = path11.join(candidate, "pubspec.yaml");
-      if (!fs12.existsSync(pubspecPath)) continue;
-      const content = fs12.readFileSync(pubspecPath, "utf8");
+      const candidate = path12.join(baseDir, entry.name);
+      const pubspecPath = path12.join(candidate, "pubspec.yaml");
+      if (!fs13.existsSync(pubspecPath)) continue;
+      const content = fs13.readFileSync(pubspecPath, "utf8");
       const pubspec = YAML3.parse(content);
       const deps = {
         ...pubspec?.dependencies,
@@ -1697,30 +2268,30 @@ function displayArchitecture(info) {
   const L = "\u2514\u2500\u2500 ";
   const I = "\u2502   ";
   const S = "    ";
-  console.log(chalk7.bold(chalk7.cyan(info.projectName)) + chalk7.gray(`  (${info.root})`));
+  console.log(chalk8.bold(chalk8.cyan(info.projectName)) + chalk8.gray(`  (${info.root})`));
   console.log(`${I}`);
   if (info.apps.length > 0) {
-    console.log(chalk7.white(`${T}apps/`));
+    console.log(chalk8.white(`${T}apps/`));
     for (let i = 0; i < info.apps.length; i++) {
       const app = info.apps[i];
       const prefix = i === info.apps.length - 1 ? `${I}${S}${L}` : `${I}${S}${T}`;
-      console.log(`${prefix}${chalk7.green(app.name)}`);
+      console.log(`${prefix}${chalk8.green(app.name)}`);
     }
   }
   if (info.packages.length > 0) {
     const rootPkgs = info.packages.filter(
-      (p) => !p.dir.includes(`${path11.sep}features${path11.sep}`)
+      (p) => !p.dir.includes(`${path12.sep}features${path12.sep}`)
     );
     const featurePkgs = info.packages.filter(
-      (p) => p.dir.includes(`${path11.sep}features${path11.sep}`)
+      (p) => p.dir.includes(`${path12.sep}features${path12.sep}`)
     );
-    console.log(chalk7.white(`${T}packages/`));
+    console.log(chalk8.white(`${T}packages/`));
     for (let i = 0; i < rootPkgs.length; i++) {
       const pkg2 = rootPkgs[i];
       const isLast = i === rootPkgs.length - 1 && featurePkgs.length === 0;
       const prefix = isLast ? `${I}${S}${L}` : `${I}${S}${T}`;
-      const deps = pkg2.keyDeps.length > 0 ? chalk7.dim(` [${pkg2.keyDeps.join(", ")}]`) : "";
-      console.log(`${prefix}${chalk7.yellow(pkg2.name)}${deps}`);
+      const deps = pkg2.keyDeps.length > 0 ? chalk8.dim(` [${pkg2.keyDeps.join(", ")}]`) : "";
+      console.log(`${prefix}${chalk8.yellow(pkg2.name)}${deps}`);
     }
     if (featurePkgs.length > 0) {
       console.log(`${I}${S}${T}features/`);
@@ -1728,21 +2299,21 @@ function displayArchitecture(info) {
         const pkg2 = featurePkgs[i];
         const isLast = i === featurePkgs.length - 1;
         const prefix = isLast ? `${I}${S}${S}${L}` : `${I}${S}${S}${T}`;
-        const deps = pkg2.keyDeps.length > 0 ? chalk7.dim(` [${pkg2.keyDeps.join(", ")}]`) : "";
-        console.log(`${prefix}${chalk7.yellow(pkg2.name)}${deps}`);
+        const deps = pkg2.keyDeps.length > 0 ? chalk8.dim(` [${pkg2.keyDeps.join(", ")}]`) : "";
+        console.log(`${prefix}${chalk8.yellow(pkg2.name)}${deps}`);
       }
     }
   }
   if (info.hasDesignSystem) {
-    const tiers = info.designSystemTiers.length > 0 ? chalk7.dim(` (${info.designSystemTiers.join(", ")})`) : "";
-    console.log(`${T}${chalk7.magenta("design_system")}${tiers}`);
+    const tiers = info.designSystemTiers.length > 0 ? chalk8.dim(` (${info.designSystemTiers.join(", ")})`) : "";
+    console.log(`${T}${chalk8.magenta("design_system")}${tiers}`);
   }
-  const bookDir = path11.join(info.root, "book");
-  if (fs12.existsSync(bookDir)) {
-    console.log(`${T}${chalk7.blue("book/")}` + chalk7.dim(" (Docusaurus)"));
+  const bookDir = path12.join(info.root, "book");
+  if (fs13.existsSync(bookDir)) {
+    console.log(`${T}${chalk8.blue("book/")}` + chalk8.dim(" (Docusaurus)"));
   }
-  if (fs12.existsSync(path11.join(info.root, "melos.yaml"))) {
-    console.log(`${L}${chalk7.gray("melos.yaml")}`);
+  if (fs13.existsSync(path12.join(info.root, "melos.yaml"))) {
+    console.log(`${L}${chalk8.gray("melos.yaml")}`);
   }
   console.log();
 }
@@ -1754,7 +2325,7 @@ async function resolveProject() {
   s.start("Analyzing current directory...");
   const cwdProject = analyzeProject(process.cwd());
   if (cwdProject && (cwdProject.hasFreezed || cwdProject.hasBloc)) {
-    s.stop(`Found ${chalk8.green(cwdProject.projectName)}`);
+    s.stop(`Found ${chalk9.green(cwdProject.projectName)}`);
     return cwdProject;
   }
   s.message("Looking for Melos monorepo...");
@@ -1767,8 +2338,8 @@ async function resolveProject() {
     }
   }
   s.message("Scanning for Flutter projects...");
-  const homeDev = path12.join(os.homedir(), "Development");
-  if (fs13.existsSync(homeDev)) {
+  const homeDev = path13.join(os.homedir(), "Development");
+  if (fs14.existsSync(homeDev)) {
     const projects = discoverProjects(homeDev, 2);
     if (projects.length > 0) {
       s.stop(`Found ${projects.length} Flutter project(s)`);
@@ -1776,12 +2347,12 @@ async function resolveProject() {
     }
   }
   s.stop("No Flutter projects found");
-  clack.outro(chalk8.red("Could not find any Flutter project with freezed or flutter_bloc."));
+  clack.outro(chalk9.red("Could not find any Flutter project with freezed or flutter_bloc."));
   return null;
 }
 async function selectPackage(projects) {
   if (projects.length === 1) {
-    clack.log.info(`Using ${chalk8.green(projects[0].projectName)}`);
+    clack.log.info(`Using ${chalk9.green(projects[0].projectName)}`);
     return projects[0];
   }
   const selected = await clack.select({
@@ -1789,7 +2360,7 @@ async function selectPackage(projects) {
     options: projects.map((p) => ({
       value: p,
       label: p.projectName,
-      hint: path12.relative(os.homedir(), p.projectRoot)
+      hint: path13.relative(os.homedir(), p.projectRoot)
     }))
   });
   if (clack.isCancel(selected)) {
@@ -1837,13 +2408,13 @@ async function blocFlow(project) {
         clack.cancel("Cancelled");
         return;
       }
-      targetDir = path12.resolve(customPath);
+      targetDir = path13.resolve(customPath);
     } else {
-      targetDir = path12.join(project.projectRoot, "lib", "features", feature);
+      targetDir = path13.join(project.projectRoot, "lib", "features", feature);
     }
-  } else if (fs13.existsSync(path12.join(project.projectRoot, "lib", "bloc"))) {
-    targetDir = path12.join(project.projectRoot, "lib", "bloc");
-    clack.log.info(`Target: ${chalk8.cyan("lib/bloc/")}`);
+  } else if (fs14.existsSync(path13.join(project.projectRoot, "lib", "bloc"))) {
+    targetDir = path13.join(project.projectRoot, "lib", "bloc");
+    clack.log.info(`Target: ${chalk9.cyan("lib/bloc/")}`);
   } else {
     clack.note(
       "No lib/features/ directory found. Provide a target path manually.",
@@ -1860,7 +2431,7 @@ async function blocFlow(project) {
       clack.cancel("Cancelled");
       return;
     }
-    targetDir = path12.resolve(customPath);
+    targetDir = path13.resolve(customPath);
   }
   const defaultRun = project.hasBuildRunner;
   const runBuildRunner2 = await clack.confirm({
@@ -1879,10 +2450,10 @@ async function blocFlow(project) {
       buildRunner: runBuildRunner2
     });
     genSpinner.stop("BLoC generated");
-    clack.outro(chalk8.green("Done!"));
+    clack.outro(chalk9.green("Done!"));
   } catch (error) {
     genSpinner.stop("Failed");
-    clack.outro(chalk8.red(`Error: ${error}`));
+    clack.outro(chalk9.red(`Error: ${error}`));
   }
 }
 async function widgetFlow() {
@@ -1890,14 +2461,14 @@ async function widgetFlow() {
   const ds = detectDesignSystem(projectRoot);
   if (!ds) {
     clack.outro(
-      chalk8.red(
+      chalk9.red(
         "No design system detected. Run this command from a project with wl_design_system/ directory."
       )
     );
     return;
   }
   clack.log.info(
-    `Design system: ${chalk8.cyan(path12.relative(projectRoot, ds.componentsDir))}`
+    `Design system: ${chalk9.cyan(path13.relative(projectRoot, ds.componentsDir))}`
   );
   const name = await clack.text({
     message: "Widget name (snake_case, without wl_ prefix)",
@@ -1962,17 +2533,17 @@ async function widgetFlow() {
         genSpinner.stop(`Use-case skipped: ${e}`);
       }
     }
-    clack.outro(chalk8.green("Done!"));
+    clack.outro(chalk9.green("Done!"));
   } catch (error) {
     genSpinner.stop("Failed");
-    clack.outro(chalk8.red(`Error: ${error}`));
+    clack.outro(chalk9.red(`Error: ${error}`));
   }
 }
 async function useCaseFlow() {
   const ds = detectDesignSystem(process.cwd());
   if (!ds) {
     clack.outro(
-      chalk8.red(
+      chalk9.red(
         "No design system detected. Ensure wl_design_system/ directory exists."
       )
     );
@@ -1980,7 +2551,7 @@ async function useCaseFlow() {
   }
   if (!ds.widgetbookDir) {
     clack.outro(
-      chalk8.red(
+      chalk9.red(
         "No widgetbook package detected. Ensure apps/widgetbook/ exists."
       )
     );
@@ -2029,18 +2600,18 @@ async function useCaseFlow() {
       buildRunner: runBuildRunner2
     });
     genSpinner.stop("Use-case generated");
-    clack.outro(chalk8.green("Done!"));
+    clack.outro(chalk9.green("Done!"));
   } catch (error) {
     genSpinner.stop("Failed");
-    clack.outro(chalk8.red(`Error: ${error}`));
+    clack.outro(chalk9.red(`Error: ${error}`));
   }
 }
 function findBffFiles(dir) {
   const results = [];
-  if (!fs13.existsSync(dir)) return results;
-  const entries = fs13.readdirSync(dir, { withFileTypes: true });
+  if (!fs14.existsSync(dir)) return results;
+  const entries = fs14.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path12.join(dir, entry.name);
+    const fullPath = path13.join(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...findBffFiles(fullPath));
     } else if (entry.isFile() && entry.name.endsWith(".dart") && !entry.name.includes(".g.")) {
@@ -2052,8 +2623,8 @@ function findBffFiles(dir) {
 function inferBffFile(bffFiles, endpointPath) {
   const firstSegment = endpointPath.replace(/^\//, "").split("/")[0].toLowerCase();
   if (!firstSegment) return null;
-  const withDomains = bffFiles.filter((f) => /^bff_.+_api\.dart$/.test(path12.basename(f))).map((f) => {
-    const base = path12.basename(f, ".dart");
+  const withDomains = bffFiles.filter((f) => /^bff_.+_api\.dart$/.test(path13.basename(f))).map((f) => {
+    const base = path13.basename(f, ".dart");
     const domain = base.replace(/^bff_/, "").replace(/_api$/, "");
     return { file: f, domain };
   });
@@ -2080,19 +2651,19 @@ async function resolveEndpointProject() {
     s.message(`Monorepo found at ${monorepoRoot}`);
     const packageBases = ["packages", "packages/features"];
     for (const base of packageBases) {
-      const baseDir = path12.join(monorepoRoot, base);
-      if (!fs13.existsSync(baseDir)) continue;
-      const entries = fs13.readdirSync(baseDir, { withFileTypes: true });
+      const baseDir = path13.join(monorepoRoot, base);
+      if (!fs14.existsSync(baseDir)) continue;
+      const entries = fs14.readdirSync(baseDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        const candidate = path12.join(baseDir, entry.name);
-        if (!fs13.existsSync(path12.join(candidate, "pubspec.yaml"))) continue;
-        const bffPath = path12.join(candidate, "lib", "data", "api", "bff");
-        s.message(`Checking ${candidate} \u2192 bff exists: ${fs13.existsSync(bffPath)}`);
-        if (fs13.existsSync(bffPath)) {
+        const candidate = path13.join(baseDir, entry.name);
+        if (!fs14.existsSync(path13.join(candidate, "pubspec.yaml"))) continue;
+        const bffPath = path13.join(candidate, "lib", "data", "api", "bff");
+        s.message(`Checking ${candidate} \u2192 bff exists: ${fs14.existsSync(bffPath)}`);
+        if (fs14.existsSync(bffPath)) {
           const project2 = analyzeProject(candidate);
           if (project2) {
-            s.stop(`Using ${chalk8.green(project2.projectName)}`);
+            s.stop(`Using ${chalk9.green(project2.projectName)}`);
             return project2;
           }
         }
@@ -2102,8 +2673,8 @@ async function resolveEndpointProject() {
     s.message("No monorepo root found");
   }
   const cwdProject = analyzeProject(process.cwd());
-  if (cwdProject && fs13.existsSync(path12.join(cwdProject.projectRoot, "lib", "data", "api", "bff"))) {
-    s.stop(`Using ${chalk8.green(cwdProject.projectName)}`);
+  if (cwdProject && fs14.existsSync(path13.join(cwdProject.projectRoot, "lib", "data", "api", "bff"))) {
+    s.stop(`Using ${chalk9.green(cwdProject.projectName)}`);
     return cwdProject;
   }
   s.stop("No BFF package found");
@@ -2112,33 +2683,33 @@ async function resolveEndpointProject() {
     placeholder: "e.g. /path/to/my-package or ./packages/core",
     validate: (v) => {
       if (!v.trim()) return "Path is required";
-      const resolved2 = path12.resolve(v.trim());
-      if (!fs13.existsSync(resolved2)) return "Path does not exist";
-      if (!fs13.existsSync(path12.join(resolved2, "pubspec.yaml"))) return "No pubspec.yaml found at this path";
-      if (!fs13.existsSync(path12.join(resolved2, "lib", "data", "api", "bff"))) return "No lib/data/api/bff/ found at this path";
+      const resolved2 = path13.resolve(v.trim());
+      if (!fs14.existsSync(resolved2)) return "Path does not exist";
+      if (!fs14.existsSync(path13.join(resolved2, "pubspec.yaml"))) return "No pubspec.yaml found at this path";
+      if (!fs14.existsSync(path13.join(resolved2, "lib", "data", "api", "bff"))) return "No lib/data/api/bff/ found at this path";
     }
   });
   if (clack.isCancel(manualPath)) {
     clack.cancel("Cancelled");
     return null;
   }
-  const resolved = path12.resolve(manualPath);
+  const resolved = path13.resolve(manualPath);
   const project = analyzeProject(resolved);
   if (!project) {
-    clack.outro(chalk8.red(`Could not analyze project at ${resolved}`));
+    clack.outro(chalk9.red(`Could not analyze project at ${resolved}`));
     return null;
   }
-  clack.log.info(`Using ${chalk8.green(project.projectName)}`);
+  clack.log.info(`Using ${chalk9.green(project.projectName)}`);
   return project;
 }
 async function endpointFlow() {
   const project = await resolveEndpointProject();
   if (!project) return;
-  const lib = path12.join(project.projectRoot, "lib");
-  const bffDir = path12.join(lib, "data", "api", "bff");
+  const lib = path13.join(project.projectRoot, "lib");
+  const bffDir = path13.join(lib, "data", "api", "bff");
   const bffFiles = findBffFiles(bffDir);
   if (bffFiles.length === 0) {
-    clack.outro(chalk8.red("No BFF API files found. Ensure lib/data/api/bff/ exists with .dart files."));
+    clack.outro(chalk9.red("No BFF API files found. Ensure lib/data/api/bff/ exists with .dart files."));
     return;
   }
   const httpMethod = await clack.select({
@@ -2168,13 +2739,13 @@ async function endpointFlow() {
   }
   let bffApiFile = inferBffFile(bffFiles, endpointPath);
   if (bffApiFile) {
-    clack.log.info(`Auto-detected BFF file: ${chalk8.cyan(path12.basename(bffApiFile))}`);
+    clack.log.info(`Auto-detected BFF file: ${chalk9.cyan(path13.basename(bffApiFile))}`);
   } else {
     const selected = await clack.select({
       message: "Could not auto-detect BFF file. Select one:",
       options: bffFiles.map((f) => ({
         value: f,
-        label: path12.relative(bffDir, f)
+        label: path13.relative(bffDir, f)
       }))
     });
     if (clack.isCancel(selected)) {
@@ -2238,14 +2809,14 @@ async function endpointFlow() {
       diLazySingleton
     });
     genSpinner.stop("Endpoint generated");
-    clack.outro(chalk8.green("Done!"));
+    clack.outro(chalk9.green("Done!"));
   } catch (error) {
     genSpinner.stop("Failed");
-    clack.outro(chalk8.red(`Error: ${error}`));
+    clack.outro(chalk9.red(`Error: ${error}`));
   }
 }
 async function docsInteractiveMode() {
-  clack.intro(chalk8.bgCyan(chalk8.black(" wlmaker docs ")));
+  clack.intro(chalk9.bgCyan(chalk9.black(" wlmaker docs ")));
   const action = await clack.select({
     message: "What do you want to do?",
     options: [
@@ -2260,44 +2831,200 @@ async function docsInteractiveMode() {
   }
   switch (action) {
     case "serve": {
+      const serveMode = await clack.select({
+        message: "How do you want to view the docs?",
+        options: [
+          { value: "local", label: "Local", hint: "Start Docusaurus dev server locally" },
+          { value: "remote", label: "Remote", hint: "Open the deployed docs in your browser" }
+        ]
+      });
+      if (clack.isCancel(serveMode)) {
+        clack.cancel("Cancelled");
+        return;
+      }
+      if (serveMode === "remote") {
+        const challenge = await clack.text({
+          message: "Pregunta de seguridad: Qu\xE9 dice mechi cuando tiene una duda en el dise\xF1o?",
+          placeholder: "...",
+          validate: (input) => {
+            const normalized = input.trim().toLowerCase().replace(/[áä]/g, "a").replace(/[éë]/g, "e").replace(/[íï]/g, "i").replace(/[óö]/g, "o").replace(/[úü]/g, "u");
+            const expected = "deja le pregunto a cesita";
+            if (normalized !== expected) {
+              return "Respuesta incorrecta. Vuelve cuando sepas el lore.";
+            }
+          }
+        });
+        if (clack.isCancel(challenge)) {
+          clack.cancel("Cancelled");
+          return;
+        }
+        const remoteUrl = "https://dc-wl-docs.web.app/development_workflow/";
+        if (!remoteUrl) {
+          clack.outro(chalk9.red("Remote docs URL not configured. Set WL_DOCS_URL in your environment."));
+          return;
+        }
+        clack.log.info(`Opening remote docs: ${chalk9.cyan(remoteUrl)}`);
+        execSync2(`open "${remoteUrl}"`, { stdio: "ignore" });
+        clack.outro(chalk9.green("Opened remote docs in browser"));
+        return;
+      }
       const bookDir = detectBookDir(process.cwd());
       if (!bookDir) {
         clack.outro(
-          chalk8.red("No Docusaurus book/ directory found. Run from a monorepo root.")
+          chalk9.red("No Docusaurus book/ directory found. Run from a monorepo root.")
         );
         return;
       }
-      clack.log.info(`Serving docs from ${chalk8.cyan(bookDir)}`);
+      clack.log.info(`Serving docs from ${chalk9.cyan(bookDir)}`);
       await serveBook(bookDir);
       break;
     }
     case "commands": {
       const commands = discoverCommands(process.cwd());
       if (commands.length === 0) {
-        clack.outro(chalk8.yellow("No commands found. Run from a monorepo root."));
+        clack.outro(chalk9.yellow("No commands found. Run from a monorepo root."));
         return;
       }
-      clack.log.info(`Found ${chalk8.green(commands.length.toString())} command(s)`);
+      clack.log.info(`Found ${chalk9.green(commands.length.toString())} command(s)`);
       displayCommands(commands);
-      clack.outro(chalk8.green("Done!"));
+      clack.outro(chalk9.green("Done!"));
       break;
     }
     case "architecture": {
       const info = discoverArchitecture(process.cwd());
       if (!info) {
         clack.outro(
-          chalk8.yellow("No monorepo detected. Run from within a Melos monorepo.")
+          chalk9.yellow("No monorepo detected. Run from within a Melos monorepo.")
         );
         return;
       }
       displayArchitecture(info);
-      clack.outro(chalk8.green("Done!"));
+      clack.outro(chalk9.green("Done!"));
       break;
     }
   }
 }
+var SCREAMING_SNAKE_REGEX = /^[A-Z][A-Z0-9_]*$/;
+async function envVarFlow() {
+  const monorepoRoot = findMonorepoRoot(process.cwd());
+  if (!monorepoRoot) {
+    clack.outro(chalk9.red("Not inside a monorepo. Run from within a Melos monorepo."));
+    return;
+  }
+  const apps = discoverAppsWithEnv(monorepoRoot);
+  if (apps.length === 0) {
+    clack.outro(chalk9.red("No apps with env/ directory found in the monorepo."));
+    return;
+  }
+  const variableName = await clack.text({
+    message: "Variable name (SCREAMING_SNAKE_CASE)",
+    placeholder: "MY_FEATURE_FLAG",
+    validate: (v) => {
+      if (!v.trim()) return "Name is required";
+      if (!SCREAMING_SNAKE_REGEX.test(v)) return "Must be SCREAMING_SNAKE_CASE (uppercase, numbers, underscores)";
+    }
+  });
+  if (clack.isCancel(variableName)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  const dartType = await clack.select({
+    message: "Variable type",
+    options: [
+      { value: "String", label: "String" },
+      { value: "int", label: "int" },
+      { value: "bool", label: "bool" },
+      { value: "List<String>", label: "List<String>" }
+    ]
+  });
+  if (clack.isCancel(dartType)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  const selectedType = dartType;
+  const defaultValue = await clack.text({
+    message: "Default value (leave empty to skip)",
+    placeholder: selectedType === "bool" ? "false" : selectedType === "int" ? "0" : "",
+    validate: (v) => {
+      if (!v || !v.trim()) return void 0;
+      if (selectedType === "int" && !/^-?\d+$/.test(v)) return "Must be an integer";
+      if (selectedType === "bool" && !["true", "false"].includes(v)) return "Must be true or false";
+    }
+  });
+  if (clack.isCancel(defaultValue)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  const selectedApps = await clack.multiselect({
+    message: "Select apps to add the variable to",
+    options: [
+      { value: "__all__", label: "All apps" },
+      ...apps.map((app) => ({ value: app, label: app }))
+    ],
+    required: true
+  });
+  if (clack.isCancel(selectedApps)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  const appsList = selectedApps.includes("__all__") ? apps : selectedApps;
+  const includeInRemoteConfig = await clack.confirm({
+    message: "Add to VendorsModule RemoteConfig defaultValues?",
+    initialValue: true
+  });
+  if (clack.isCancel(includeInRemoteConfig)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  let vendorsTargets = [];
+  if (includeInRemoteConfig) {
+    const vendorsModules = discoverVendorsModules(monorepoRoot);
+    if (vendorsModules.length > 0) {
+      const vendorsSelection = await clack.multiselect({
+        message: "Which VendorsModule(s) to update?",
+        options: [
+          { value: "__all__", label: "All vendors" },
+          ...vendorsModules.map((v) => ({ value: v, label: v }))
+        ],
+        required: true
+      });
+      if (clack.isCancel(vendorsSelection)) {
+        clack.cancel("Cancelled");
+        return;
+      }
+      vendorsTargets = vendorsSelection.includes("__all__") ? vendorsModules : vendorsSelection;
+    }
+  }
+  const includeInAppConfig = await clack.confirm({
+    message: "Add to AppConfig entity and AppConfigModel?",
+    initialValue: true
+  });
+  if (clack.isCancel(includeInAppConfig)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  const genSpinner = clack.spinner();
+  genSpinner.start("Adding environment variable...");
+  try {
+    await createEnvVar({
+      monorepoRoot,
+      variableName,
+      dartType: selectedType,
+      defaultValue: defaultValue || void 0,
+      selectedApps: appsList,
+      vendorsTargets,
+      includeInRemoteConfig,
+      includeInAppConfig
+    });
+    genSpinner.stop("Done");
+    clack.outro(chalk9.green("Environment variable added!"));
+  } catch (error) {
+    genSpinner.stop("Failed");
+    clack.outro(chalk9.red(`Error: ${error}`));
+  }
+}
 async function interactiveMode() {
-  clack.intro(chalk8.bgCyan(chalk8.black(" wlmaker ")));
+  clack.intro(chalk9.bgCyan(chalk9.black(" wlmaker ")));
   const createType = await clack.select({
     message: "What do you want to create?",
     options: [
@@ -2313,6 +3040,11 @@ async function interactiveMode() {
         label: "Endpoint",
         hint: "BFF Clean Architecture stack"
       },
+      {
+        value: "env-var",
+        label: "Env Var",
+        hint: "Add environment variable to monorepo stack"
+      },
       {
         value: "docs",
         label: "Docs",
@@ -2341,6 +3073,9 @@ async function interactiveMode() {
     case "endpoint":
       await endpointFlow();
       break;
+    case "env-var":
+      await envVarFlow();
+      break;
     case "docs":
       await docsInteractiveMode();
       break;
@@ -2363,7 +3098,7 @@ program.command("bloc").description("Create a new BLoC with Freezed sealed class
     try {
       await createBloc(name, options);
     } catch (error) {
-      console.error(chalk9.red(`Error: ${error}`));
+      console.error(chalk10.red(`Error: ${error}`));
       process.exit(1);
     }
   }
@@ -2380,12 +3115,12 @@ program.command("widget").description("Create a new widget in the design system"
           projectRoot: options.dir,
           buildRunner: false
         });
-        console.log(chalk9.green("Widgetbook use-case created"));
+        console.log(chalk10.green("Widgetbook use-case created"));
       } catch {
-        console.log(chalk9.yellow("Use-case skipped (may already exist)"));
+        console.log(chalk10.yellow("Use-case skipped (may already exist)"));
       }
     } catch (error) {
-      console.error(chalk9.red(`Error: ${error}`));
+      console.error(chalk10.red(`Error: ${error}`));
       process.exit(1);
     }
   }
@@ -2398,7 +3133,7 @@ program.command("usecase").description("Create a Widgetbook use-case for an exis
         buildRunner: options.buildRunner
       });
     } catch (error) {
-      console.error(chalk9.red(`Error: ${error}`));
+      console.error(chalk10.red(`Error: ${error}`));
       process.exit(1);
     }
   }
@@ -2408,30 +3143,33 @@ program.command("endpoint").description("Generate Clean Architecture stack for a
   if (!project) return;
   await endpointFlow(project);
 });
+program.command("env-var").description("Add an environment variable across the Flutter monorepo").action(async () => {
+  await envVarFlow();
+});
 var docsCmd = program.command("docs").description("Project documentation tools");
 docsCmd.command("serve").description("Start Docusaurus dev server").option("-d, --dir <path>", "project root directory", process.cwd()).action(async (options) => {
   const bookDir = detectBookDir(options.dir);
   if (!bookDir) {
-    console.error(chalk9.red("No Docusaurus book/ directory found. Run from a monorepo root."));
+    console.error(chalk10.red("No Docusaurus book/ directory found. Run from a monorepo root."));
     process.exit(1);
   }
-  console.log(chalk9.cyan(`Serving docs from ${bookDir}`));
+  console.log(chalk10.cyan(`Serving docs from ${bookDir}`));
   await serveBook(bookDir);
 });
 docsCmd.command("commands").description("Show Makefile & melos commands reference").option("-d, --dir <path>", "project root directory", process.cwd()).action(async (options) => {
   const commands = discoverCommands(options.dir);
   if (commands.length === 0) {
-    console.log(chalk9.yellow("No commands found. Run from a monorepo root."));
+    console.log(chalk10.yellow("No commands found. Run from a monorepo root."));
     return;
   }
-  console.log(chalk9.green(`Found ${commands.length} command(s)
+  console.log(chalk10.green(`Found ${commands.length} command(s)
 `));
   displayCommands(commands);
 });
 docsCmd.command("architecture").description("Display monorepo architecture tree").option("-d, --dir <path>", "project root directory", process.cwd()).action(async (options) => {
   const info = discoverArchitecture(options.dir);
   if (!info) {
-    console.log(chalk9.yellow("No monorepo detected. Run from within a Melos monorepo."));
+    console.log(chalk10.yellow("No monorepo detected. Run from within a Melos monorepo."));
     return;
   }
   displayArchitecture(info);