wlmaker 1.2.8 → 1.2.10

package/dist/cli.mjs

@@ -3,7 +3,7 @@
 // src/cli.ts
 import { createRequire } from "module";
 import { Command } from "commander";
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 
 // src/core/create-bloc.ts
 import * as fs3 from "fs";
@@ -106,17 +106,17 @@ function hasBuildRunner(projectRoot) {
   return /build_runner/.test(pubspec);
 }
 function runBuildRunner(projectRoot) {
-  return new Promise((resolve3) => {
+  return new Promise((resolve4) => {
     const child = spawn(
       "dart",
       ["run", "build_runner", "build", "--delete-conflicting-outputs"],
       { cwd: projectRoot, stdio: "inherit" }
     );
     child.on("close", (code) => {
-      resolve3();
+      resolve4();
     });
     child.on("error", () => {
-      resolve3();
+      resolve4();
     });
   });
 }
@@ -956,18 +956,357 @@ async function createUseCase(name, tierInput, options) {
 }
 
 // src/interactive.ts
-import * as fs8 from "fs";
+import * as fs10 from "fs";
 import * as os from "os";
-import * as path8 from "path";
+import * as path9 from "path";
 import * as clack from "@clack/prompts";
+import chalk5 from "chalk";
+
+// src/core/create-endpoint.ts
+import * as fs9 from "fs";
+import * as path8 from "path";
 import chalk4 from "chalk";
+import { pascalCase as pascalCase4, camelCase } from "change-case";
+
+// src/core/endpoint-templates.ts
+function entityBoilerplate(pascal) {
+  return `class ${pascal}Entity {
+  // TODO: Define fields
+
+  const ${pascal}Entity();
+}
+`;
+}
+function modelBoilerplate(name, pascal) {
+  return `import 'package:json_annotation/json_annotation.dart';
+import '../../domain/entities/${name}/${name}_entity.dart';
+
+part '${name}_model.g.dart';
+
+@JsonSerializable()
+class ${pascal}Model extends ${pascal}Entity {
+  const ${pascal}Model() : super();
+
+  factory ${pascal}Model.fromJson(Map<String, dynamic> json) =>
+      _$${pascal}ModelFromJson(json);
+
+  @override
+  Map<String, dynamic> toJson() => _$${pascal}ModelToJson(this);
+}
+`;
+}
+function requestModelBoilerplate(name, pascal) {
+  return `import 'package:json_annotation/json_annotation.dart';
+
+part '${name}_request_model.g.dart';
+
+@JsonSerializable()
+class ${pascal}RequestModel {
+  // TODO: Define fields
+
+  ${pascal}RequestModel();
+
+  factory ${pascal}RequestModel.fromJson(Map<String, dynamic> json) =>
+      _$${pascal}RequestModelFromJson(json);
+
+  Map<String, dynamic> toJson() => _$${pascal}RequestModelToJson(this);
+}
+`;
+}
+function useCaseTemplate2(name, pascal, method, params, returnType, repositoryInterface) {
+  const hasParams = params.length > 0;
+  const paramsClass = hasParams ? `
+  class Params {
+${params.map((p) => `    final ${p.type} ${p.name};`).join("\n")}
+    const Params({${params.map((p) => `required this.${p.name}`).join(", ")}});
+  }
+` : "";
+  const callParams = hasParams ? "Params params" : "";
+  const callReturn = `Future<${returnType}>`;
+  const args = hasParams ? params.map((p) => `params.${p.name}`).join(", ") : "";
+  return `import 'package:dartz/dartz.dart';
+import '../../repositories/${repositoryInterface}.dart';
+
+class ${pascal}UseCase {
+  final ${repositoryInterface} _repository;
+
+  ${pascal}UseCase(this._repository);
+${paramsClass}
+  ${callReturn} call(${callParams}) async {
+    return await _repository.${method}(${args});
+  }
+}
+`;
+}
+function retrofitMethod(methodName, path10, httpMethod, params, returnType) {
+  const httpAnnotation = `@${httpMethod.toUpperCase()}('${path10}')`;
+  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}`;
+    if (p.isQuery) return `@Query('${p.name}') ${p.type} ${p.name}`;
+    return `${p.type} ${p.name}`;
+  }).join(", ");
+  return `${httpAnnotation}
+  Future<${returnType}> ${methodName}(${paramList});`;
+}
+function datasourceMethod(methodName, returnType, params) {
+  const paramList = params.map((p) => `${p.type} ${p.name}`).join(", ");
+  return `Future<${returnType}> ${methodName}(${paramList}) async {
+    // TODO: implement ${methodName}
+    throw UnimplementedError();
+  }`;
+}
+function repositoryInterfaceMethod(methodName, returnType, params) {
+  const paramList = params.map((p) => `${p.type} ${p.name}`).join(", ");
+  return `Future<${returnType}> ${methodName}(${paramList});`;
+}
+function repositoryImplMethod(methodName, returnType, params, datasourceName) {
+  const paramList = params.map((p) => `${p.type} ${p.name}`).join(", ");
+  const args = params.map((p) => p.name).join(", ");
+  return `@override
+  Future<${returnType}> ${methodName}(${paramList}) async {
+    return await ${datasourceName}.${methodName}(${args});
+  }`;
+}
+
+// src/core/dart-injector.ts
+import * as fs8 from "fs";
+function injectMethod(filePath, className, methodCode) {
+  const content = fs8.readFileSync(filePath, "utf8");
+  const classRegex = new RegExp(`class\\s+${className}\\s*[^{]*\\{`);
+  const classMatch = content.match(classRegex);
+  if (!classMatch) {
+    throw new Error(`Class "${className}" not found in ${filePath}`);
+  }
+  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}" in ${filePath}`);
+  }
+  const methodSignature = methodCode.trim().split("\n")[0].trim();
+  if (content.includes(methodSignature)) {
+    return;
+  }
+  const indentedMethod = methodCode.split("\n").map((line) => line.trim() ? `  ${line}` : "").join("\n");
+  const newContent = content.slice(0, classEnd) + "\n" + indentedMethod + "\n" + content.slice(classEnd);
+  fs8.writeFileSync(filePath, newContent);
+}
+function injectImport(filePath, importLine) {
+  const content = fs8.readFileSync(filePath, "utf8");
+  if (content.includes(importLine.trim())) {
+    return;
+  }
+  const importRegex = /^import\s+[^;]+;/gm;
+  const imports = [...content.matchAll(importRegex)];
+  if (imports.length > 0) {
+    const lastImport = imports[imports.length - 1];
+    const insertPos = lastImport.index + lastImport[0].length;
+    const newContent = content.slice(0, insertPos) + "\n" + importLine + content.slice(insertPos);
+    fs8.writeFileSync(filePath, newContent);
+  } else {
+    fs8.writeFileSync(filePath, importLine + "\n\n" + content);
+  }
+}
+function injectExport(filePath, exportLine) {
+  let content = "";
+  if (fs8.existsSync(filePath)) {
+    content = fs8.readFileSync(filePath, "utf8");
+  }
+  if (content.includes(exportLine)) {
+    return;
+  }
+  const lines = content.split("\n").filter((l) => l.trim().length > 0);
+  lines.push(exportLine);
+  lines.sort();
+  fs8.writeFileSync(filePath, lines.join("\n") + "\n");
+}
+
+// src/core/create-endpoint.ts
+async function createEndpoint(options) {
+  const lib = path8.join(options.projectRoot, "lib");
+  const pascal = pascalCase4(options.useCaseName);
+  const useCasePascal = pascalCase4(options.useCaseName);
+  const useCaseSnake = options.useCaseName;
+  const needsBody = ["POST", "PUT", "PATCH"].includes(options.httpMethod);
+  const domain = extractDomain(options.bffApiFile);
+  const datasourceFile = path8.join(lib, "data", "datasources", `${domain}_rest_datasource.dart`);
+  const datasourceClassName = `${pascalCase4(domain)}RestDataSource`;
+  const repositoryInterfaceFile = path8.join(lib, "domain", "repositories", `${domain}_repository.dart`);
+  const repositoryInterfaceName = `${pascalCase4(domain)}Repository`;
+  const repositoryImplFile = path8.join(lib, "data", "repositories", `${domain}_repository_data.dart`);
+  const repositoryImplClassName = `${pascalCase4(domain)}RepositoryData`;
+  const feature = domain;
+  const pathParams = extractPathParams(options.endpointPath);
+  const methodParams = buildMethodParams(options, pathParams, needsBody);
+  const methodParamsForSignature = methodParams.map((p) => ({ name: p.name, type: p.type }));
+  const returnType = `${pascal}Entity`;
+  const repositoryInterfaceSnake = path8.basename(repositoryInterfaceFile, ".dart");
+  const spinner2 = (msg) => console.log(chalk4.cyan(`  \u2192 ${msg}`));
+  spinner2("Generating entity");
+  const entityDir = path8.join(lib, "domain", "entities", feature, useCaseSnake);
+  fs9.mkdirSync(entityDir, { recursive: true });
+  fs9.writeFileSync(
+    path8.join(entityDir, `${useCaseSnake}_entity.dart`),
+    entityBoilerplate(pascal)
+  );
+  spinner2("Generating model");
+  const modelDir = path8.join(lib, "data", "models", feature, useCaseSnake);
+  fs9.mkdirSync(modelDir, { recursive: true });
+  fs9.writeFileSync(
+    path8.join(modelDir, `${useCaseSnake}_model.dart`),
+    modelBoilerplate(useCaseSnake, pascal)
+  );
+  if (needsBody) {
+    spinner2("Generating request model");
+    const reqModelDir = path8.join(lib, "data", "models", feature, useCaseSnake);
+    fs9.mkdirSync(reqModelDir, { recursive: true });
+    fs9.writeFileSync(
+      path8.join(reqModelDir, `${useCaseSnake}_request_model.dart`),
+      requestModelBoilerplate(useCaseSnake, pascal)
+    );
+  }
+  spinner2("Injecting Retrofit method");
+  const bffPath = path8.resolve(options.bffApiFile);
+  if (fs9.existsSync(bffPath)) {
+    const retrofitParams = buildRetrofitParams(options, pathParams, needsBody);
+    const retrofitReturnType = `${pascal}Model`;
+    const method = retrofitMethod(
+      camelCase(options.useCaseName),
+      options.endpointPath,
+      options.httpMethod,
+      retrofitParams,
+      retrofitReturnType
+    );
+    injectMethod(bffPath, extractClassName(bffPath), method);
+    const modelImport = `import 'package:${feature}/data/models/${useCaseSnake}/${useCaseSnake}_model.dart';`;
+    injectImport(bffPath, modelImport);
+  } else {
+    console.log(chalk4.yellow(`  \u26A0 BFF API file not found: ${bffPath}`));
+  }
+  spinner2("Injecting datasource method");
+  const dsPath = path8.resolve(datasourceFile);
+  if (fs9.existsSync(dsPath)) {
+    const dsMethod = datasourceMethod(
+      camelCase(options.useCaseName),
+      returnType,
+      methodParamsForSignature
+    );
+    injectMethod(dsPath, datasourceClassName, dsMethod);
+  } else {
+    console.log(chalk4.yellow(`  \u26A0 Datasource file not found: ${dsPath}`));
+  }
+  spinner2("Injecting repository interface method");
+  const repoIfacePath = path8.resolve(repositoryInterfaceFile);
+  if (fs9.existsSync(repoIfacePath)) {
+    const ifaceMethod = repositoryInterfaceMethod(
+      camelCase(options.useCaseName),
+      returnType,
+      methodParamsForSignature
+    );
+    injectMethod(repoIfacePath, repositoryInterfaceName, ifaceMethod);
+    const entityImport = `import 'package:${feature}/domain/entities/${useCaseSnake}/${useCaseSnake}_entity.dart';`;
+    injectImport(repoIfacePath, entityImport);
+  } else {
+    console.log(chalk4.yellow(`  \u26A0 Repository interface not found: ${repoIfacePath}`));
+  }
+  spinner2("Injecting repository implementation method");
+  const repoImplPath = path8.resolve(repositoryImplFile);
+  if (fs9.existsSync(repoImplPath)) {
+    const dsVarName = camelCase(datasourceClassName);
+    const implMethod = repositoryImplMethod(
+      camelCase(options.useCaseName),
+      returnType,
+      methodParamsForSignature,
+      dsVarName
+    );
+    injectMethod(repoImplPath, repositoryImplClassName, implMethod);
+  } else {
+    console.log(chalk4.yellow(`  \u26A0 Repository implementation not found: ${repoImplPath}`));
+  }
+  spinner2("Generating UseCase");
+  const useCaseDir = path8.join(lib, "domain", "usecases", feature);
+  fs9.mkdirSync(useCaseDir, { recursive: true });
+  fs9.writeFileSync(
+    path8.join(useCaseDir, `${useCaseSnake}_usecase.dart`),
+    useCaseTemplate2(
+      useCaseSnake,
+      useCasePascal,
+      camelCase(options.useCaseName),
+      methodParamsForSignature,
+      returnType,
+      repositoryInterfaceSnake
+    )
+  );
+  spinner2("Updating barrel file");
+  const barrelPath = path8.join(useCaseDir, "usecases.dart");
+  const exportLine = `export '${useCaseSnake}_usecase.dart';`;
+  injectExport(barrelPath, exportLine);
+  console.log(chalk4.green(`
+\u2713 Endpoint "${options.useCaseName}" generated successfully.`));
+}
+function extractDomain(bffApiFile) {
+  const baseName = path8.basename(bffApiFile);
+  const match = baseName.match(/^bff_(.+)_api\.dart$/);
+  if (match) return match[1];
+  return baseName.replace(/\.dart$/, "");
+}
+function extractPathParams(endpointPath) {
+  const regex = /\{(\w+)\}/g;
+  const params = [];
+  let match;
+  while ((match = regex.exec(endpointPath)) !== null) {
+    params.push({ name: match[1], type: "String" });
+  }
+  return params;
+}
+function buildMethodParams(options, pathParams, hasRequestBody) {
+  const params = [...pathParams];
+  if (hasRequestBody) {
+    const reqPascal = pascalCase4(options.useCaseName);
+    params.push({ name: "body", type: `${reqPascal}RequestModel` });
+  }
+  return params;
+}
+function buildRetrofitParams(options, pathParams, hasRequestBody) {
+  const params = [];
+  for (const pp of pathParams) {
+    params.push({ ...pp, isPath: true });
+  }
+  if (hasRequestBody) {
+    const reqPascal = pascalCase4(options.useCaseName);
+    params.push({ name: "body", type: `${reqPascal}RequestModel`, isBody: true });
+  }
+  return params;
+}
+function extractClassName(filePath) {
+  const content = fs9.readFileSync(filePath, "utf8");
+  const match = content.match(/class\s+(\w+)\s+/);
+  if (!match) throw new Error(`No class found in ${filePath}`);
+  return match[1];
+}
+
+// src/interactive.ts
 var SNAKE_CASE_REGEX4 = /^[a-z][a-z0-9_]*$/;
 async function resolveProject() {
   const s = clack.spinner();
   s.start("Analyzing current directory...");
   const cwdProject = analyzeProject(process.cwd());
   if (cwdProject && (cwdProject.hasFreezed || cwdProject.hasBloc)) {
-    s.stop(`Found ${chalk4.green(cwdProject.projectName)}`);
+    s.stop(`Found ${chalk5.green(cwdProject.projectName)}`);
     return cwdProject;
   }
   s.message("Looking for Melos monorepo...");
@@ -980,8 +1319,8 @@ async function resolveProject() {
     }
   }
   s.message("Scanning for Flutter projects...");
-  const homeDev = path8.join(os.homedir(), "Development");
-  if (fs8.existsSync(homeDev)) {
+  const homeDev = path9.join(os.homedir(), "Development");
+  if (fs10.existsSync(homeDev)) {
     const projects = discoverProjects(homeDev, 2);
     if (projects.length > 0) {
       s.stop(`Found ${projects.length} Flutter project(s)`);
@@ -989,12 +1328,12 @@ async function resolveProject() {
     }
   }
   s.stop("No Flutter projects found");
-  clack.outro(chalk4.red("Could not find any Flutter project with freezed or flutter_bloc."));
+  clack.outro(chalk5.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 ${chalk4.green(projects[0].projectName)}`);
+    clack.log.info(`Using ${chalk5.green(projects[0].projectName)}`);
     return projects[0];
   }
   const selected = await clack.select({
@@ -1002,7 +1341,7 @@ async function selectPackage(projects) {
     options: projects.map((p) => ({
       value: p,
       label: p.projectName,
-      hint: path8.relative(os.homedir(), p.projectRoot)
+      hint: path9.relative(os.homedir(), p.projectRoot)
     }))
   });
   if (clack.isCancel(selected)) {
@@ -1050,13 +1389,13 @@ async function blocFlow(project) {
         clack.cancel("Cancelled");
         return;
       }
-      targetDir = path8.resolve(customPath);
+      targetDir = path9.resolve(customPath);
     } else {
-      targetDir = path8.join(project.projectRoot, "lib", "features", feature);
+      targetDir = path9.join(project.projectRoot, "lib", "features", feature);
     }
-  } else if (fs8.existsSync(path8.join(project.projectRoot, "lib", "bloc"))) {
-    targetDir = path8.join(project.projectRoot, "lib", "bloc");
-    clack.log.info(`Target: ${chalk4.cyan("lib/bloc/")}`);
+  } else if (fs10.existsSync(path9.join(project.projectRoot, "lib", "bloc"))) {
+    targetDir = path9.join(project.projectRoot, "lib", "bloc");
+    clack.log.info(`Target: ${chalk5.cyan("lib/bloc/")}`);
   } else {
     clack.note(
       "No lib/features/ directory found. Provide a target path manually.",
@@ -1073,7 +1412,7 @@ async function blocFlow(project) {
       clack.cancel("Cancelled");
       return;
     }
-    targetDir = path8.resolve(customPath);
+    targetDir = path9.resolve(customPath);
   }
   const defaultRun = project.hasBuildRunner;
   const runBuildRunner2 = await clack.confirm({
@@ -1092,10 +1431,10 @@ async function blocFlow(project) {
       buildRunner: runBuildRunner2
     });
     genSpinner.stop("BLoC generated");
-    clack.outro(chalk4.green("Done!"));
+    clack.outro(chalk5.green("Done!"));
   } catch (error) {
     genSpinner.stop("Failed");
-    clack.outro(chalk4.red(`Error: ${error}`));
+    clack.outro(chalk5.red(`Error: ${error}`));
   }
 }
 async function widgetFlow() {
@@ -1103,14 +1442,14 @@ async function widgetFlow() {
   const ds = detectDesignSystem(projectRoot);
   if (!ds) {
     clack.outro(
-      chalk4.red(
+      chalk5.red(
         "No design system detected. Run this command from a project with wl_design_system/ directory."
       )
     );
     return;
   }
   clack.log.info(
-    `Design system: ${chalk4.cyan(path8.relative(projectRoot, ds.componentsDir))}`
+    `Design system: ${chalk5.cyan(path9.relative(projectRoot, ds.componentsDir))}`
   );
   const name = await clack.text({
     message: "Widget name (snake_case, without wl_ prefix)",
@@ -1175,17 +1514,17 @@ async function widgetFlow() {
         genSpinner.stop(`Use-case skipped: ${e}`);
       }
     }
-    clack.outro(chalk4.green("Done!"));
+    clack.outro(chalk5.green("Done!"));
   } catch (error) {
     genSpinner.stop("Failed");
-    clack.outro(chalk4.red(`Error: ${error}`));
+    clack.outro(chalk5.red(`Error: ${error}`));
   }
 }
 async function useCaseFlow(project) {
   const ds = detectDesignSystem(project.projectRoot);
   if (!ds) {
     clack.outro(
-      chalk4.red(
+      chalk5.red(
         "No design system detected. Ensure wl_design_system/ directory exists."
       )
     );
@@ -1193,7 +1532,7 @@ async function useCaseFlow(project) {
   }
   if (!ds.widgetbookDir) {
     clack.outro(
-      chalk4.red(
+      chalk5.red(
         "No widgetbook package detected. Ensure apps/widgetbook/ exists."
       )
     );
@@ -1242,14 +1581,119 @@ async function useCaseFlow(project) {
       buildRunner: runBuildRunner2
     });
     genSpinner.stop("Use-case generated");
-    clack.outro(chalk4.green("Done!"));
+    clack.outro(chalk5.green("Done!"));
+  } catch (error) {
+    genSpinner.stop("Failed");
+    clack.outro(chalk5.red(`Error: ${error}`));
+  }
+}
+async function endpointFlow(project) {
+  const lib = path9.join(project.projectRoot, "lib");
+  const httpMethod = await clack.select({
+    message: "HTTP Method",
+    options: [
+      { value: "GET", label: "GET" },
+      { value: "POST", label: "POST" },
+      { value: "PUT", label: "PUT" },
+      { value: "PATCH", label: "PATCH" },
+      { value: "DELETE", label: "DELETE" }
+    ]
+  });
+  if (clack.isCancel(httpMethod)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  const endpointPath = await clack.text({
+    message: "Endpoint path (e.g. /products/{id})",
+    placeholder: "/api/users/{id}",
+    validate: (v) => {
+      if (!v.trim()) return "Path is required";
+    }
+  });
+  if (clack.isCancel(endpointPath)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  const bffDir = path9.join(lib, "data", "api", "bff");
+  let bffApiFile = "";
+  if (fs10.existsSync(bffDir)) {
+    const dartFiles = fs10.readdirSync(bffDir).filter((f) => f.endsWith(".dart")).sort();
+    if (dartFiles.length > 0) {
+      const selected = await clack.select({
+        message: "Select BFF API file",
+        options: dartFiles.map((f) => ({
+          value: path9.join(bffDir, f),
+          label: f
+        }))
+      });
+      if (clack.isCancel(selected)) {
+        clack.cancel("Cancelled");
+        return;
+      }
+      bffApiFile = selected;
+    } else {
+      const customPath = await clack.text({
+        message: "BFF API file path (no .dart files found in bff/)",
+        placeholder: "lib/data/api/bff/my_api.dart",
+        validate: (v) => {
+          if (!v.trim()) return "Path is required";
+        }
+      });
+      if (clack.isCancel(customPath)) {
+        clack.cancel("Cancelled");
+        return;
+      }
+      bffApiFile = path9.resolve(customPath);
+    }
+  } else {
+    const customPath = await clack.text({
+      message: "BFF API file path (bff/ dir not found)",
+      placeholder: "lib/data/api/bff/my_api.dart",
+      validate: (v) => {
+        if (!v.trim()) return "Path is required";
+      }
+    });
+    if (clack.isCancel(customPath)) {
+      clack.cancel("Cancelled");
+      return;
+    }
+    bffApiFile = path9.resolve(customPath);
+  }
+  const methodLower = httpMethod.toLowerCase();
+  const pathSegments = endpointPath.replace(/^\//, "").split("/").filter((s) => !s.startsWith("{"));
+  const inferredName = pathSegments.length > 0 ? `${methodLower}_${pathSegments.join("_")}` : `${methodLower}_data`;
+  const useCaseName = await clack.text({
+    message: "UseCase name (snake_case)",
+    placeholder: inferredName,
+    initialValue: inferredName,
+    validate: (v) => {
+      if (!v.trim()) return "Name is required";
+      if (!SNAKE_CASE_REGEX4.test(v)) return "Must be snake_case";
+    }
+  });
+  if (clack.isCancel(useCaseName)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  const genSpinner = clack.spinner();
+  genSpinner.start("Generating endpoint stack...");
+  try {
+    await createEndpoint({
+      projectRoot: project.projectRoot,
+      httpMethod,
+      endpointPath,
+      bffApiFile,
+      useCaseName
+    });
+    genSpinner.stop("Endpoint generated");
+    clack.outro(chalk5.green("Done!"));
   } catch (error) {
     genSpinner.stop("Failed");
-    clack.outro(chalk4.red(`Error: ${error}`));
+    clack.outro(chalk5.red(`Error: ${error}`));
   }
 }
 async function interactiveMode() {
-  clack.intro(chalk4.bgCyan(chalk4.black(" wlmaker ")));
+  clack.intro(chalk5.bgCyan(chalk5.black(" wlmaker ")));
   const createType = await clack.select({
     message: "What do you want to create?",
     options: [
@@ -1259,6 +1703,11 @@ async function interactiveMode() {
         value: "usecase",
         label: "Widgetbook Use-Case",
         hint: "Component showcase"
+      },
+      {
+        value: "endpoint",
+        label: "Endpoint",
+        hint: "BFF Clean Architecture stack"
       }
     ]
   });
@@ -1283,6 +1732,12 @@ async function interactiveMode() {
       await useCaseFlow(project);
       break;
     }
+    case "endpoint": {
+      const project = await resolveProject();
+      if (!project) return;
+      await endpointFlow(project);
+      break;
+    }
   }
 }
 
@@ -1302,7 +1757,7 @@ program.command("bloc").description("Create a new BLoC with Freezed sealed class
     try {
       await createBloc(name, options);
     } catch (error) {
-      console.error(chalk5.red(`Error: ${error}`));
+      console.error(chalk6.red(`Error: ${error}`));
       process.exit(1);
     }
   }
@@ -1319,12 +1774,12 @@ program.command("widget").description("Create a new widget in the design system"
           projectRoot: options.dir,
           buildRunner: false
         });
-        console.log(chalk5.green("Widgetbook use-case created"));
+        console.log(chalk6.green("Widgetbook use-case created"));
       } catch {
-        console.log(chalk5.yellow("Use-case skipped (may already exist)"));
+        console.log(chalk6.yellow("Use-case skipped (may already exist)"));
       }
     } catch (error) {
-      console.error(chalk5.red(`Error: ${error}`));
+      console.error(chalk6.red(`Error: ${error}`));
       process.exit(1);
     }
   }
@@ -1337,11 +1792,16 @@ program.command("usecase").description("Create a Widgetbook use-case for an exis
         buildRunner: options.buildRunner
       });
     } catch (error) {
-      console.error(chalk5.red(`Error: ${error}`));
+      console.error(chalk6.red(`Error: ${error}`));
       process.exit(1);
     }
   }
 );
+program.command("endpoint").description("Generate Clean Architecture stack for a BFF endpoint").action(async () => {
+  const project = await resolveProject();
+  if (!project) return;
+  await endpointFlow(project);
+});
 program.action(async () => {
   await interactiveMode();
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wlmaker",
-  "version": "1.2.8",
+  "version": "1.2.10",
   "description": "Create Flutter BLoCs with Freezed sealed classes from the terminal",
   "keywords": [
     "flutter",