wlmaker 1.2.8 → 1.2.9

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,453 @@ 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/json-to-dart.ts
+function jsonToFields(jsonStr) {
+  const parsed = JSON.parse(jsonStr);
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    throw new Error("Expected a JSON object at the top level");
+  }
+  return objectToFields(parsed);
+}
+function objectToFields(obj) {
+  const fields = [];
+  for (const [key, value] of Object.entries(obj)) {
+    fields.push({
+      name: key,
+      dartType: dartTypeOf(value, key),
+      isNullable: value === null
+    });
+  }
+  return fields;
+}
+function dartTypeOf(value, nameHint) {
+  if (value === null) return "dynamic";
+  if (typeof value === "string") return "String";
+  if (typeof value === "boolean") return "bool";
+  if (typeof value === "number") {
+    return Number.isInteger(value) ? "int" : "double";
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "List<dynamic>";
+    const elementType = dartTypeOf(value[0], nameHint);
+    return `List<${elementType}>`;
+  }
+  if (typeof value === "object") {
+    return "Map<String, dynamic>";
+  }
+  return "dynamic";
+}
+function fieldsToConstructorParams(fields, indent = "    ") {
+  return fields.map((f) => {
+    const nullable = f.isNullable ? "?" : "";
+    return `${indent}required ${f.dartType}${nullable} ${f.name},`;
+  }).join("\n");
+}
+function fieldsToFromJson(fields, modelName) {
+  const entries = fields.map((f) => {
+    if (f.dartType.startsWith("List<")) {
+      return `      ${f.name}: (${_jsonFieldName(f)} as List<dynamic>).map((e) => e as ${_extractGenericType(f.dartType)}).toList(),`;
+    }
+    return `      ${f.name}: ${_jsonFieldName(f)} as ${f.dartType}${f.isNullable ? "?" : ""},`;
+  }).join("\n");
+  return `factory ${modelName}.fromJson(Map<String, dynamic> json) => ${modelName}(
+${entries}
+    );`;
+}
+function fieldsToJson(fields, modelName) {
+  const entries = fields.map((f) => `      '${f.name}': ${f.name},`).join("\n");
+  return `Map<String, dynamic> toJson() => {
+${entries}
+    };`;
+}
+function _jsonFieldName(f) {
+  return `json['${f.name}']`;
+}
+function _extractGenericType(listType) {
+  const match = listType.match(/^List<(.+)>$/);
+  return match ? match[1] : "dynamic";
+}
+
+// src/core/endpoint-templates.ts
+function entityTemplate(name, pascal, fields) {
+  const params = fieldsToConstructorParams(fields);
+  const props = fields.map((f) => {
+    const nullable = f.isNullable ? "?" : "";
+    return `  final ${f.dartType}${nullable} ${f.name};`;
+  }).join("\n");
+  return `class ${pascal}Entity {
+${props}
+
+  const ${pascal}Entity({
+${params}
+  });
+}
+`;
+}
+function modelTemplate(name, pascal, fields) {
+  const params = fieldsToConstructorParams(fields);
+  const props = fields.map((f) => {
+    const nullable = f.isNullable ? "?" : "";
+    return `  final ${f.dartType}${nullable} ${f.name};`;
+  }).join("\n");
+  const fromJson = fieldsToFromJson(fields, `${pascal}Model`);
+  const toJson = fieldsToJson(fields, `${pascal}Model`);
+  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({
+${params}
+  }) : super(
+${fields.map((f) => `      ${f.name}: ${f.name},`).join("\n")}
+  );
+
+  ${fromJson}
+
+  ${toJson}
+
+  factory ${pascal}Model.fromJson(Map<String, dynamic> json) =>
+      _$${pascal}ModelFromJson(json);
+
+  @override
+  Map<String, dynamic> toJson() => _$${pascal}ModelToJson(this);
+}
+`;
+}
+function requestModelTemplate(name, pascal, fields) {
+  const params = fieldsToConstructorParams(fields);
+  const props = fields.map((f) => {
+    const nullable = f.isNullable ? "?" : "";
+    return `  final ${f.dartType}${nullable} ${f.name};`;
+  }).join("\n");
+  return `import 'package:json_annotation/json_annotation.dart';
+
+part '${name}_request_model.g.dart';
+
+@JsonSerializable()
+class ${pascal}RequestModel {
+${props}
+
+  ${pascal}RequestModel({
+${params}
+  });
+
+  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.responseModelName);
+  const useCasePascal = pascalCase4(options.useCaseName);
+  const useCaseSnake = options.useCaseName;
+  const hasRequestBody = ["POST", "PUT", "PATCH"].includes(options.httpMethod) && options.requestFields;
+  const pathParams = extractPathParams(options.endpointPath);
+  const methodParams = buildMethodParams(options, pathParams, hasRequestBody);
+  const methodParamsForSignature = methodParams.map((p) => ({ name: p.name, type: p.type }));
+  const returnType = `${pascal}Entity`;
+  const repositoryInterfaceSnake = path8.basename(options.repositoryInterfaceFile, ".dart");
+  const spinner2 = (msg) => console.log(chalk4.cyan(`  \u2192 ${msg}`));
+  if (options.responseFields && options.responseFields.length > 0) {
+    spinner2("Generating entity");
+    const entityDir = path8.join(lib, "domain", "entities", options.feature);
+    fs9.mkdirSync(entityDir, { recursive: true });
+    fs9.writeFileSync(
+      path8.join(entityDir, `${options.responseModelName}_entity.dart`),
+      entityTemplate(options.responseModelName, pascal, options.responseFields)
+    );
+    spinner2("Generating model");
+    const modelDir = path8.join(lib, "data", "models", options.feature);
+    fs9.mkdirSync(modelDir, { recursive: true });
+    fs9.writeFileSync(
+      path8.join(modelDir, `${options.responseModelName}_model.dart`),
+      modelTemplate(options.responseModelName, pascal, options.responseFields)
+    );
+  }
+  if (hasRequestBody && options.requestFields && options.requestModelName) {
+    spinner2("Generating request model");
+    const reqPascal = pascalCase4(options.requestModelName);
+    const reqModelDir = path8.join(lib, "data", "models", options.feature);
+    fs9.mkdirSync(reqModelDir, { recursive: true });
+    fs9.writeFileSync(
+      path8.join(reqModelDir, `${options.requestModelName}_request_model.dart`),
+      requestModelTemplate(options.requestModelName, reqPascal, options.requestFields)
+    );
+  }
+  spinner2("Injecting Retrofit method");
+  const bffPath = path8.resolve(options.bffApiFile);
+  if (fs9.existsSync(bffPath)) {
+    const retrofitParams = buildRetrofitParams(options, pathParams, hasRequestBody);
+    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:${options.feature}/data/models/${options.responseModelName}/${options.responseModelName}_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(options.datasourceFile);
+  if (fs9.existsSync(dsPath)) {
+    const dsMethod = datasourceMethod(
+      camelCase(options.useCaseName),
+      returnType,
+      methodParamsForSignature
+    );
+    injectMethod(dsPath, options.datasourceClassName, dsMethod);
+  } else {
+    console.log(chalk4.yellow(`  \u26A0 Datasource file not found: ${dsPath}`));
+  }
+  spinner2("Injecting repository interface method");
+  const repoIfacePath = path8.resolve(options.repositoryInterfaceFile);
+  if (fs9.existsSync(repoIfacePath)) {
+    const ifaceMethod = repositoryInterfaceMethod(
+      camelCase(options.useCaseName),
+      returnType,
+      methodParamsForSignature
+    );
+    injectMethod(repoIfacePath, options.repositoryInterfaceName, ifaceMethod);
+    const entityImport = `import 'package:${options.feature}/domain/entities/${options.responseModelName}/${options.responseModelName}_entity.dart';`;
+    injectImport(repoIfacePath, entityImport);
+  } else {
+    console.log(chalk4.yellow(`  \u26A0 Repository interface not found: ${repoIfacePath}`));
+  }
+  spinner2("Injectating repository implementation method");
+  const repoImplPath = path8.resolve(options.repositoryImplFile);
+  if (fs9.existsSync(repoImplPath)) {
+    const dsVarName = camelCase(options.datasourceClassName);
+    const implMethod = repositoryImplMethod(
+      camelCase(options.useCaseName),
+      returnType,
+      methodParamsForSignature,
+      dsVarName
+    );
+    injectMethod(repoImplPath, options.repositoryImplClassName, implMethod);
+  } else {
+    console.log(chalk4.yellow(`  \u26A0 Repository implementation not found: ${repoImplPath}`));
+  }
+  spinner2("Generating UseCase");
+  const useCaseDir = path8.join(lib, "domain", "usecases", options.feature);
+  fs9.mkdirSync(useCaseDir, { recursive: true });
+  fs9.writeFileSync(
+    path8.join(useCaseDir, `${useCaseSnake}_usecase.dart`),
+    useCaseTemplate2(
+      useCaseSnake,
+      useCasePascal,
+      camelCase(options.useCaseName),
+      methodParamsForSignature,
+      returnType,
+      repositoryInterfaceName
+    )
+  );
+  spinner2("Updating barrel file");
+  const barrelPath = path8.join(useCaseDir, "usecases.dart");
+  const exportLine = `export '${useCaseSnake}_usecase.dart';`;
+  injectExport(barrelPath, exportLine);
+  if (options.runBuildRunner) {
+    const projectRoot = findPubspecDir(options.projectRoot);
+    if (projectRoot && hasBuildRunner(projectRoot)) {
+      spinner2("Running build_runner...");
+      await runBuildRunner(projectRoot);
+      console.log(chalk4.green("  \u2713 build_runner completed."));
+    } else {
+      console.log(chalk4.yellow("  \u26A0 Skipping build_runner (not found)."));
+    }
+  }
+  console.log(chalk4.green(`
+\u2713 Endpoint "${options.useCaseName}" generated successfully.`));
+}
+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 && options.requestModelName) {
+    const reqPascal = pascalCase4(options.requestModelName);
+    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 && options.requestModelName) {
+    const reqPascal = pascalCase4(options.requestModelName);
+    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
+import { pascalCase as pascalCase5 } from "change-case";
 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 +1415,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 +1424,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 +1437,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 +1485,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 +1508,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 +1527,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 +1538,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 +1610,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 +1628,7 @@ async function useCaseFlow(project) {
   }
   if (!ds.widgetbookDir) {
     clack.outro(
-      chalk4.red(
+      chalk5.red(
         "No widgetbook package detected. Ensure apps/widgetbook/ exists."
       )
     );
@@ -1242,14 +1677,358 @@ 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(chalk4.red(`Error: ${error}`));
+    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. /cp/{zipCode})",
+    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
+          })),
+          { value: "__custom__", label: "Custom path..." }
+        ]
+      });
+      if (clack.isCancel(selected)) {
+        clack.cancel("Cancelled");
+        return;
+      }
+      if (selected === "__custom__") {
+        const customPath = await clack.text({
+          message: "BFF API file path",
+          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 {
+        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 responseChoice = await clack.select({
+    message: "Response model",
+    options: [
+      { value: "existing", label: "Use existing model", hint: "Reference an already created model" },
+      { value: "json", label: "Paste JSON", hint: "Generate entity + model from JSON" }
+    ]
+  });
+  if (clack.isCancel(responseChoice)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  let responseModelName = "";
+  let responseFields;
+  if (responseChoice === "json") {
+    const modelName = await clack.text({
+      message: "Response model name (snake_case)",
+      placeholder: "e.g. user_profile",
+      validate: (v) => {
+        if (!v.trim()) return "Name is required";
+        if (!SNAKE_CASE_REGEX4.test(v)) return "Must be snake_case";
+      }
+    });
+    if (clack.isCancel(modelName)) {
+      clack.cancel("Cancelled");
+      return;
+    }
+    responseModelName = modelName;
+    const jsonStr = await clack.text({
+      message: "Paste the JSON response",
+      placeholder: '{ "id": 1, "name": "John" }',
+      validate: (v) => {
+        if (!v.trim()) return "JSON is required";
+        try {
+          JSON.parse(v);
+        } catch {
+          return "Invalid JSON";
+        }
+      }
+    });
+    if (clack.isCancel(jsonStr)) {
+      clack.cancel("Cancelled");
+      return;
+    }
+    responseFields = jsonToFields(jsonStr);
+  } else {
+    const modelName = await clack.text({
+      message: "Existing response model name (snake_case)",
+      placeholder: "e.g. user_profile",
+      validate: (v) => {
+        if (!v.trim()) return "Name is required";
+      }
+    });
+    if (clack.isCancel(modelName)) {
+      clack.cancel("Cancelled");
+      return;
+    }
+    responseModelName = modelName;
+  }
+  let requestModelName;
+  let requestFields;
+  const needsBody = ["POST", "PUT", "PATCH"].includes(httpMethod);
+  if (needsBody) {
+    const requestChoice = await clack.select({
+      message: "Request body",
+      options: [
+        { value: "json", label: "Paste JSON", hint: "Generate request model from JSON" },
+        { value: "existing", label: "Use existing model", hint: "Reference an already created model" },
+        { value: "none", label: "No body", hint: "Just path/query params" }
+      ]
+    });
+    if (clack.isCancel(requestChoice)) {
+      clack.cancel("Cancelled");
+      return;
+    }
+    if (requestChoice === "json") {
+      const reqName = await clack.text({
+        message: "Request model name (snake_case)",
+        placeholder: `e.g. create_${responseModelName}`,
+        validate: (v) => {
+          if (!v.trim()) return "Name is required";
+          if (!SNAKE_CASE_REGEX4.test(v)) return "Must be snake_case";
+        }
+      });
+      if (clack.isCancel(reqName)) {
+        clack.cancel("Cancelled");
+        return;
+      }
+      requestModelName = reqName;
+      const reqJson = await clack.text({
+        message: "Paste the request JSON body",
+        placeholder: '{ "name": "John", "email": "john@example.com" }',
+        validate: (v) => {
+          if (!v.trim()) return "JSON is required";
+          try {
+            JSON.parse(v);
+          } catch {
+            return "Invalid JSON";
+          }
+        }
+      });
+      if (clack.isCancel(reqJson)) {
+        clack.cancel("Cancelled");
+        return;
+      }
+      requestFields = jsonToFields(reqJson);
+    } else if (requestChoice === "existing") {
+      const reqName = await clack.text({
+        message: "Existing request model name (snake_case)",
+        placeholder: `e.g. create_${responseModelName}`,
+        validate: (v) => {
+          if (!v.trim()) return "Name is required";
+        }
+      });
+      if (clack.isCancel(reqName)) {
+        clack.cancel("Cancelled");
+        return;
+      }
+      requestModelName = reqName;
+    }
+  }
+  const pathSegments = endpointPath.replace(/^\//, "").split("/").filter((s) => !s.startsWith("{"));
+  const inferredName = pathSegments.length > 0 ? "get_" + pathSegments.join("_") : "get_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 datasourceFile = await clack.text({
+    message: "Datasource file path",
+    placeholder: `lib/data/datasources/${responseModelName}_datasource.dart`,
+    validate: (v) => {
+      if (!v.trim()) return "Path is required";
+    }
+  });
+  if (clack.isCancel(datasourceFile)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  const datasourceClassName = await clack.text({
+    message: "Datasource class name",
+    placeholder: `${pascalCase5(responseModelName)}Datasource`,
+    initialValue: `${pascalCase5(responseModelName)}Datasource`,
+    validate: (v) => {
+      if (!v.trim()) return "Class name is required";
+    }
+  });
+  if (clack.isCancel(datasourceClassName)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  const repositoryInterfaceFile = await clack.text({
+    message: "Repository interface file path",
+    placeholder: `lib/domain/repositories/${responseModelName}_repository.dart`,
+    validate: (v) => {
+      if (!v.trim()) return "Path is required";
+    }
+  });
+  if (clack.isCancel(repositoryInterfaceFile)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  const repositoryInterfaceName2 = await clack.text({
+    message: "Repository interface name",
+    placeholder: `${pascalCase5(responseModelName)}Repository`,
+    initialValue: `${pascalCase5(responseModelName)}Repository`,
+    validate: (v) => {
+      if (!v.trim()) return "Name is required";
+    }
+  });
+  if (clack.isCancel(repositoryInterfaceName2)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  const repositoryImplFile = await clack.text({
+    message: "Repository implementation file path",
+    placeholder: `lib/data/repositories/${responseModelName}_repository_impl.dart`,
+    validate: (v) => {
+      if (!v.trim()) return "Path is required";
+    }
+  });
+  if (clack.isCancel(repositoryImplFile)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  const repositoryImplClassName = await clack.text({
+    message: "Repository implementation class name",
+    placeholder: `${pascalCase5(responseModelName)}RepositoryImpl`,
+    initialValue: `${pascalCase5(responseModelName)}RepositoryImpl`,
+    validate: (v) => {
+      if (!v.trim()) return "Name is required";
+    }
+  });
+  if (clack.isCancel(repositoryImplClassName)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  const feature = await clack.text({
+    message: "Feature name (snake_case, for directory grouping)",
+    placeholder: responseModelName,
+    initialValue: responseModelName,
+    validate: (v) => {
+      if (!v.trim()) return "Feature name is required";
+      if (!SNAKE_CASE_REGEX4.test(v)) return "Must be snake_case";
+    }
+  });
+  if (clack.isCancel(feature)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  const runBuildRunner2 = await clack.confirm({
+    message: "Run build_runner after generation?",
+    initialValue: project.hasBuildRunner
+  });
+  if (clack.isCancel(runBuildRunner2)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  const genSpinner = clack.spinner();
+  genSpinner.start("Generating endpoint stack...");
+  try {
+    await createEndpoint({
+      projectRoot: project.projectRoot,
+      httpMethod,
+      endpointPath,
+      bffApiFile,
+      responseModelName,
+      responseFields,
+      requestModelName,
+      requestFields,
+      useCaseName,
+      datasourceFile,
+      datasourceClassName,
+      repositoryInterfaceFile,
+      repositoryInterfaceName: repositoryInterfaceName2,
+      repositoryImplFile,
+      repositoryImplClassName,
+      feature,
+      runBuildRunner: runBuildRunner2
+    });
+    genSpinner.stop("Endpoint generated");
+    clack.outro(chalk5.green("Done!"));
+  } catch (error) {
+    genSpinner.stop("Failed");
+    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 +2038,11 @@ async function interactiveMode() {
         value: "usecase",
         label: "Widgetbook Use-Case",
         hint: "Component showcase"
+      },
+      {
+        value: "endpoint",
+        label: "Endpoint",
+        hint: "BFF Clean Architecture stack"
       }
     ]
   });
@@ -1283,6 +2067,12 @@ async function interactiveMode() {
       await useCaseFlow(project);
       break;
     }
+    case "endpoint": {
+      const project = await resolveProject();
+      if (!project) return;
+      await endpointFlow(project);
+      break;
+    }
   }
 }
 
@@ -1302,7 +2092,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 +2109,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 +2127,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.9",
   "description": "Create Flutter BLoCs with Freezed sealed classes from the terminal",
   "keywords": [
     "flutter",