wlmaker 1.2.12 → 1.3.0

package/dist/cli.mjs

@@ -3,7 +3,7 @@
 // src/cli.ts
 import { createRequire } from "module";
 import { Command } from "commander";
-import chalk6 from "chalk";
+import chalk9 from "chalk";
 
 // src/core/create-bloc.ts
 import * as fs3 from "fs";
@@ -956,24 +956,30 @@ async function createUseCase(name, tierInput, options) {
 }
 
 // src/interactive.ts
-import * as fs10 from "fs";
+import * as fs13 from "fs";
 import * as os from "os";
-import * as path9 from "path";
+import * as path12 from "path";
 import * as clack from "@clack/prompts";
-import chalk5 from "chalk";
+import chalk8 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";
+import { pascalCase as pascalCase4, camelCase as camelCase2 } from "change-case";
 
 // src/core/endpoint-templates.ts
+import { camelCase } from "change-case";
 function entityBoilerplate(pascal) {
-  return `class ${pascal}Entity {
+  return `import 'package:equatable/equatable.dart';
+
+class ${pascal}Entity extends Equatable {
   // TODO: Define fields
 
   const ${pascal}Entity();
+
+  @override
+  List<Object?> get props => [];
 }
 `;
 }
@@ -1019,33 +1025,32 @@ class ${pascal}RequestModel {
 }
 `;
 }
-function useCaseTemplate2(name, pascal, method, params, returnType, repositoryInterface) {
+function useCaseTemplate2(pascal, method, params, returnType, repositoryInterface, projectName) {
   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(", ")}});
+${params.map((p) => `    final ${p.type} ${p.name};`).join("\n")}
   }
 ` : "";
   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';
+  return `import 'package:${projectName}/core.dart';
 
 class ${pascal}UseCase {
-  final ${repositoryInterface} _repository;
-
   ${pascal}UseCase(this._repository);
+
+  final ${repositoryInterface} _repository;
 ${paramsClass}
   ${callReturn} call(${callParams}) async {
-    return await _repository.${method}(${args});
+    return _repository.${method}(${args});
   }
 }
 `;
 }
-function retrofitMethod(methodName, path10, httpMethod, params, returnType) {
-  const httpAnnotation = `@${httpMethod.toUpperCase()}('${path10}')`;
+function retrofitMethod(methodName, path13, httpMethod, params, returnType) {
+  const httpAnnotation = `@${httpMethod.toUpperCase()}('${path13}')`;
   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}`;
@@ -1066,20 +1071,58 @@ function repositoryInterfaceMethod(methodName, returnType, params) {
   const paramList = params.map((p) => `${p.type} ${p.name}`).join(", ");
   return `Future<${returnType}> ${methodName}(${paramList});`;
 }
-function repositoryImplMethod(methodName, returnType, modelType, params, datasourceName) {
+function repositoryImplMethod(methodName, returnType, _modelType, 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 {
-    final model = await ${datasourceName}.${methodName}(${args});
-    return model.toEntity();
+  Future<${returnType}> ${methodName}(${paramList}) {
+    // TODO: implement ${methodName}
+    throw UnimplementedError();
   }`;
 }
+function datasourceModuleRegistration(domainPascal, lazy = true) {
+  const dsClass = `${domainPascal}RestDataSource`;
+  const dsCamel = camelCase(dsClass);
+  const apiClass = `Bff${domainPascal}Api`;
+  const annotation = lazy ? "@lazySingleton\n" : "";
+  return `//============================================================================
+// ${domainPascal}
+//============================================================================
+${annotation}${dsClass} ${dsCamel}(${apiClass} api) =>
+    ${dsClass}(api: api);`;
+}
+function repositoryModuleRegistration(domainPascal, lazy = true) {
+  const repoInterface = `${domainPascal}Repository`;
+  const repoCamel = camelCase(repoInterface);
+  const repoImpl = `${domainPascal}RepositoryData`;
+  const dsClass = `${domainPascal}RestDataSource`;
+  const annotation = lazy ? "@lazySingleton\n" : "";
+  return `//============================================================================
+// ${domainPascal}
+//============================================================================
+${annotation}${repoInterface} ${repoCamel}(
+  ${dsClass} restDataSource,
+) => ${repoImpl}(restDataSource: restDataSource);`;
+}
+function useCaseModuleRegistration(useCasePascal, domainPascal, lazy = true) {
+  const useCaseClass = `${useCasePascal}UseCase`;
+  const useCaseCamel = camelCase(useCaseClass);
+  const repoInterface = `${domainPascal}Repository`;
+  const annotation = lazy ? "@lazySingleton\n" : "";
+  return `//============================================================================
+// ${domainPascal}
+//============================================================================
+${annotation}${useCaseClass} ${useCaseCamel}(${repoInterface} repository) =>
+    ${useCaseClass}(repository);`;
+}
 
 // src/core/dart-injector.ts
 import * as fs8 from "fs";
-function injectMethod(filePath, className, methodCode) {
+function injectMethod(filePath, className, methodCode, dedupKey) {
   const content = fs8.readFileSync(filePath, "utf8");
+  const dedup = dedupKey ?? findSignature(methodCode);
+  if (dedup && content.includes(dedup)) {
+    return;
+  }
   const classRegex = new RegExp(`class\\s+${className}\\s*[^{]*\\{`);
   const classMatch = content.match(classRegex);
   if (!classMatch) {
@@ -1104,14 +1147,26 @@ function injectMethod(filePath, className, methodCode) {
   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)) {
@@ -1125,6 +1180,16 @@ function injectExport(filePath, exportLine) {
   lines.sort();
   fs8.writeFileSync(filePath, lines.join("\n") + "\n");
 }
+function findSignature(methodCode) {
+  const lines = methodCode.trim().split("\n");
+  for (const line of lines) {
+    const stripped = line.trim();
+    if (stripped && !stripped.startsWith("@")) {
+      return stripped;
+    }
+  }
+  return null;
+}
 
 // src/core/create-endpoint.ts
 async function createEndpoint(options) {
@@ -1146,7 +1211,6 @@ async function createEndpoint(options) {
   const methodParamsForSignature = methodParams.map((p) => ({ name: p.name, type: p.type }));
   const modelType = `${pascal}Model`;
   const entityType = `${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);
@@ -1176,7 +1240,7 @@ async function createEndpoint(options) {
   if (fs9.existsSync(bffPath)) {
     const retrofitParams = buildRetrofitParams(options, pathParams, needsBody);
     const method = retrofitMethod(
-      camelCase(options.useCaseName),
+      camelCase2(options.useCaseName),
       options.endpointPath,
       options.httpMethod,
       retrofitParams,
@@ -1190,7 +1254,7 @@ async function createEndpoint(options) {
   const dsPath = path8.resolve(datasourceFile);
   if (fs9.existsSync(dsPath)) {
     const dsMethod = datasourceMethod(
-      camelCase(options.useCaseName),
+      camelCase2(options.useCaseName),
       modelType,
       methodParamsForSignature
     );
@@ -1202,7 +1266,7 @@ async function createEndpoint(options) {
   const repoIfacePath = path8.resolve(repositoryInterfaceFile);
   if (fs9.existsSync(repoIfacePath)) {
     const ifaceMethod = repositoryInterfaceMethod(
-      camelCase(options.useCaseName),
+      camelCase2(options.useCaseName),
       entityType,
       methodParamsForSignature
     );
@@ -1213,9 +1277,9 @@ async function createEndpoint(options) {
   spinner2("Injecting repository implementation method");
   const repoImplPath = path8.resolve(repositoryImplFile);
   if (fs9.existsSync(repoImplPath)) {
-    const dsVarName = camelCase(datasourceClassName);
+    const dsVarName = camelCase2(datasourceClassName);
     const implMethod = repositoryImplMethod(
-      camelCase(options.useCaseName),
+      camelCase2(options.useCaseName),
       entityType,
       modelType,
       methodParamsForSignature,
@@ -1231,15 +1295,20 @@ async function createEndpoint(options) {
   fs9.writeFileSync(
     path8.join(useCaseDir, `${useCaseSnake}_usecase.dart`),
     useCaseTemplate2(
-      useCaseSnake,
       useCasePascal,
-      camelCase(options.useCaseName),
+      camelCase2(options.useCaseName),
       methodParamsForSignature,
       entityType,
-      repositoryInterfaceSnake
+      repositoryInterfaceName,
+      options.projectName
     )
   );
   spinner2("Updating barrel files");
+  const dsFileName = path8.basename(datasourceFile);
+  injectExport(
+    path8.join(lib, "data", "datasources", "datasources.dart"),
+    `export '${dsFileName}';`
+  );
   const entityBarrel = path8.join(lib, "domain", "entities", feature, `${feature}.dart`);
   injectExport(entityBarrel, `export '${useCaseSnake}_entity.dart';`);
   injectExport(
@@ -1261,6 +1330,44 @@ async function createEndpoint(options) {
     path8.join(lib, "domain", "usecases", "usecases.dart"),
     `export '${feature}/${feature}.dart';`
   );
+  if (options.diTarget && options.diTarget !== "none") {
+    spinner2("Registering in DI modules");
+    const appBaseDir = findAppBasePackageDir(options.projectRoot, options.diTarget);
+    if (appBaseDir) {
+      const domainPascal = pascalCase4(domain);
+      const lazy = options.diLazySingleton !== false;
+      const dsModuleFile = path8.join(appBaseDir, "datasources_module.dart");
+      const dsRegistration = datasourceModuleRegistration(domainPascal, lazy);
+      injectModuleRegistration(
+        dsModuleFile,
+        "DataSourceModule",
+        dsRegistration,
+        `${domainPascal}RestDataSource`
+      );
+      const repoModuleFile = path8.join(appBaseDir, "repositories_module.dart");
+      const repoRegistration = repositoryModuleRegistration(domainPascal, lazy);
+      injectModuleRegistration(
+        repoModuleFile,
+        "RepositoriesModule",
+        repoRegistration,
+        `${domainPascal}RepositoryData`
+      );
+      const ucModuleFile = path8.join(appBaseDir, "usecases_module.dart");
+      const ucRegistration = useCaseModuleRegistration(useCasePascal, domainPascal, lazy);
+      injectModuleRegistration(
+        ucModuleFile,
+        "UseCasesModule",
+        ucRegistration,
+        `${useCasePascal}UseCase`
+      );
+      const coreImport = `import 'package:${options.projectName}/core.dart';`;
+      injectImport(dsModuleFile, coreImport);
+      injectImport(repoModuleFile, coreImport);
+      injectImport(ucModuleFile, coreImport);
+    } else {
+      console.log(chalk4.yellow(`  \u26A0 Package "${options.diTarget}" not found in monorepo`));
+    }
+  }
   console.log(chalk4.green(`
 \u2713 Endpoint "${options.useCaseName}" generated successfully.`));
 }
@@ -1304,6 +1411,341 @@ function extractClassName(filePath) {
   if (!match) throw new Error(`No class found in ${filePath}`);
   return match[1];
 }
+function findAppBasePackageDir(projectRoot, packageName) {
+  let dir = path8.resolve(projectRoot);
+  for (let i = 0; i < 10; i++) {
+    const candidate = path8.join(dir, "packages", packageName, "lib", "dependencies");
+    if (fs9.existsSync(candidate)) {
+      return candidate;
+    }
+    const parent = path8.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+function injectModuleRegistration(filePath, className, registrationCode, dedupKey) {
+  if (!fs9.existsSync(filePath)) {
+    console.log(chalk4.yellow(`  \u26A0 Module file not found: ${filePath}`));
+    return;
+  }
+  const content = fs9.readFileSync(filePath, "utf8");
+  if (content.includes(dedupKey)) {
+    return;
+  }
+  const classRegex = new RegExp(`class\\s+${className}\\s*[^{]*\\{`);
+  const classMatch = content.match(classRegex);
+  if (!classMatch) {
+    console.log(chalk4.yellow(`  \u26A0 Class "${className}" not found in ${filePath}`));
+    return;
+  }
+  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) {
+    console.log(chalk4.yellow(`  \u26A0 Could not find closing brace for "${className}" in ${filePath}`));
+    return;
+  }
+  const indentedCode = registrationCode.split("\n").map((line) => line.trim() ? `  ${line}` : "").join("\n");
+  const newContent = content.slice(0, classEnd) + "\n" + indentedCode + "\n" + content.slice(classEnd);
+  fs9.writeFileSync(filePath, newContent);
+}
+
+// src/core/docs-serve.ts
+import { spawn as spawn2 } from "child_process";
+import * as fs10 from "fs";
+import * as path9 from "path";
+import chalk5 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")))) {
+    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 install = spawn2("npm", ["install"], {
+        cwd: bookDir,
+        stdio: "inherit"
+      });
+      install.on("close", (code) => {
+        if (code !== 0) {
+          reject(new Error(`npm install failed with code ${code}`));
+          return;
+        }
+        startDevServer(bookDir, resolve4);
+      });
+      install.on("error", (err) => {
+        reject(err);
+      });
+    } else {
+      startDevServer(bookDir, resolve4);
+    }
+  });
+}
+function startDevServer(bookDir, done) {
+  const child = spawn2("npm", ["run", "start"], {
+    cwd: bookDir,
+    stdio: "inherit"
+  });
+  child.on("close", () => {
+    done();
+  });
+  child.on("error", () => {
+    done();
+  });
+}
+
+// src/core/docs-commands.ts
+import * as fs11 from "fs";
+import * as path10 from "path";
+import chalk6 from "chalk";
+import YAML2 from "yaml";
+function parseMakefile(filePath) {
+  if (!fs11.existsSync(filePath)) return [];
+  const content = fs11.readFileSync(filePath, "utf8");
+  const lines = content.split("\n");
+  const commands = [];
+  const source = path10.basename(filePath);
+  let pendingComments = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    if (line.startsWith("#")) {
+      const commentText = line.replace(/^#+\s?/, "").trim();
+      if (commentText) pendingComments.push(commentText);
+      continue;
+    }
+    const targetMatch = line.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)\s*:/);
+    if (targetMatch) {
+      const name = targetMatch[1];
+      if (name.startsWith(".") || name === "Makefile") {
+        pendingComments = [];
+        continue;
+      }
+      commands.push({
+        name,
+        description: pendingComments.join(" ").trim() || "",
+        source: "Makefile",
+        file: source
+      });
+      pendingComments = [];
+    } else if (line.trim() !== "") {
+      pendingComments = [];
+    }
+  }
+  return commands;
+}
+function parseMelosScripts(filePath) {
+  if (!fs11.existsSync(filePath)) return [];
+  const content = fs11.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);
+  for (const [name, value] of Object.entries(scripts)) {
+    let description = "";
+    let command = "";
+    if (typeof value === "string") {
+      command = value;
+    } else if (typeof value === "object" && value !== null) {
+      description = value.description ?? "";
+      command = value.run ?? value.exec ?? "";
+    }
+    commands.push({
+      name,
+      description: description || command,
+      source: "melos",
+      file: source
+    });
+  }
+  return commands;
+}
+function discoverCommands(startDir) {
+  const root = findMonorepoRoot(startDir) ?? startDir;
+  const commands = [];
+  const rootMakefile = path10.join(root, "Makefile");
+  commands.push(...parseMakefile(rootMakefile));
+  const melosFile = path10.join(root, "melos.yaml");
+  commands.push(...parseMelosScripts(melosFile));
+  const bookMakefile = path10.join(root, "book", "Makefile");
+  commands.push(...parseMakefile(bookMakefile));
+  return commands;
+}
+function displayCommands(commands) {
+  if (commands.length === 0) {
+    console.log(chalk6.yellow("No commands found."));
+    return;
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const cmd of commands) {
+    const key = `${cmd.source} (${cmd.file})`;
+    if (!groups.has(key)) groups.set(key, []);
+    groups.get(key).push(cmd);
+  }
+  for (const [group, entries] of groups) {
+    console.log(chalk6.bold(chalk6.cyan(`
+${group}`)));
+    console.log(chalk6.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)");
+      console.log(`  ${name} ${desc}`);
+    }
+  }
+  console.log();
+}
+
+// src/core/docs-architecture.ts
+import * as fs12 from "fs";
+import * as path11 from "path";
+import chalk7 from "chalk";
+import YAML3 from "yaml";
+var KEY_DEPS = [
+  "freezed",
+  "freezed_annotation",
+  "flutter_bloc",
+  "bloc",
+  "retrofit",
+  "retrofit_generator",
+  "json_serializable",
+  "injectable",
+  "get_it",
+  "go_router",
+  "widgetbook"
+];
+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 melos = YAML3.parse(melosContent);
+  const projectName = melos?.name ?? path11.basename(root);
+  const apps = [];
+  const appsDir = path11.join(root, "apps");
+  if (fs12.existsSync(appsDir)) {
+    for (const entry of fs12.readdirSync(appsDir, { withFileTypes: true })) {
+      if (!entry.isDirectory()) continue;
+      const candidate = path11.join(appsDir, entry.name);
+      if (fs12.existsSync(path11.join(candidate, "pubspec.yaml"))) {
+        apps.push({ name: entry.name, dir: candidate });
+      }
+    }
+  }
+  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 })) {
+      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 pubspec = YAML3.parse(content);
+      const deps = {
+        ...pubspec?.dependencies,
+        ...pubspec?.dev_dependencies
+      };
+      const keyDeps = KEY_DEPS.filter((d) => d in deps);
+      packages.push({
+        name: pubspec?.name ?? entry.name,
+        dir: candidate,
+        keyDeps
+      });
+    }
+  }
+  let hasDesignSystem = false;
+  let designSystemTiers = [];
+  const ds = detectDesignSystem(root);
+  if (ds) {
+    hasDesignSystem = true;
+    designSystemTiers = ds.availableTiers;
+  }
+  return {
+    root,
+    projectName,
+    apps,
+    packages,
+    hasDesignSystem,
+    designSystemTiers
+  };
+}
+function displayArchitecture(info) {
+  const T = "\u251C\u2500\u2500 ";
+  const L = "\u2514\u2500\u2500 ";
+  const I = "\u2502   ";
+  const S = "    ";
+  console.log(chalk7.bold(chalk7.cyan(info.projectName)) + chalk7.gray(`  (${info.root})`));
+  console.log(`${I}`);
+  if (info.apps.length > 0) {
+    console.log(chalk7.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)}`);
+    }
+  }
+  if (info.packages.length > 0) {
+    const rootPkgs = info.packages.filter(
+      (p) => !p.dir.includes(`${path11.sep}features${path11.sep}`)
+    );
+    const featurePkgs = info.packages.filter(
+      (p) => p.dir.includes(`${path11.sep}features${path11.sep}`)
+    );
+    console.log(chalk7.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}`);
+    }
+    if (featurePkgs.length > 0) {
+      console.log(`${I}${S}${T}features/`);
+      for (let i = 0; i < featurePkgs.length; i++) {
+        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}`);
+      }
+    }
+  }
+  if (info.hasDesignSystem) {
+    const tiers = info.designSystemTiers.length > 0 ? chalk7.dim(` (${info.designSystemTiers.join(", ")})`) : "";
+    console.log(`${T}${chalk7.magenta("design_system")}${tiers}`);
+  }
+  const bookDir = path11.join(info.root, "book");
+  if (fs12.existsSync(bookDir)) {
+    console.log(`${T}${chalk7.blue("book/")}` + chalk7.dim(" (Docusaurus)"));
+  }
+  if (fs12.existsSync(path11.join(info.root, "melos.yaml"))) {
+    console.log(`${L}${chalk7.gray("melos.yaml")}`);
+  }
+  console.log();
+}
 
 // src/interactive.ts
 var SNAKE_CASE_REGEX4 = /^[a-z][a-z0-9_]*$/;
@@ -1312,7 +1754,7 @@ async function resolveProject() {
   s.start("Analyzing current directory...");
   const cwdProject = analyzeProject(process.cwd());
   if (cwdProject && (cwdProject.hasFreezed || cwdProject.hasBloc)) {
-    s.stop(`Found ${chalk5.green(cwdProject.projectName)}`);
+    s.stop(`Found ${chalk8.green(cwdProject.projectName)}`);
     return cwdProject;
   }
   s.message("Looking for Melos monorepo...");
@@ -1325,8 +1767,8 @@ async function resolveProject() {
     }
   }
   s.message("Scanning for Flutter projects...");
-  const homeDev = path9.join(os.homedir(), "Development");
-  if (fs10.existsSync(homeDev)) {
+  const homeDev = path12.join(os.homedir(), "Development");
+  if (fs13.existsSync(homeDev)) {
     const projects = discoverProjects(homeDev, 2);
     if (projects.length > 0) {
       s.stop(`Found ${projects.length} Flutter project(s)`);
@@ -1334,12 +1776,12 @@ async function resolveProject() {
     }
   }
   s.stop("No Flutter projects found");
-  clack.outro(chalk5.red("Could not find any Flutter project with freezed or flutter_bloc."));
+  clack.outro(chalk8.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 ${chalk5.green(projects[0].projectName)}`);
+    clack.log.info(`Using ${chalk8.green(projects[0].projectName)}`);
     return projects[0];
   }
   const selected = await clack.select({
@@ -1347,7 +1789,7 @@ async function selectPackage(projects) {
     options: projects.map((p) => ({
       value: p,
       label: p.projectName,
-      hint: path9.relative(os.homedir(), p.projectRoot)
+      hint: path12.relative(os.homedir(), p.projectRoot)
     }))
   });
   if (clack.isCancel(selected)) {
@@ -1395,13 +1837,13 @@ async function blocFlow(project) {
         clack.cancel("Cancelled");
         return;
       }
-      targetDir = path9.resolve(customPath);
+      targetDir = path12.resolve(customPath);
     } else {
-      targetDir = path9.join(project.projectRoot, "lib", "features", feature);
+      targetDir = path12.join(project.projectRoot, "lib", "features", feature);
     }
-  } 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 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 {
     clack.note(
       "No lib/features/ directory found. Provide a target path manually.",
@@ -1418,7 +1860,7 @@ async function blocFlow(project) {
       clack.cancel("Cancelled");
       return;
     }
-    targetDir = path9.resolve(customPath);
+    targetDir = path12.resolve(customPath);
   }
   const defaultRun = project.hasBuildRunner;
   const runBuildRunner2 = await clack.confirm({
@@ -1437,10 +1879,10 @@ async function blocFlow(project) {
       buildRunner: runBuildRunner2
     });
     genSpinner.stop("BLoC generated");
-    clack.outro(chalk5.green("Done!"));
+    clack.outro(chalk8.green("Done!"));
   } catch (error) {
     genSpinner.stop("Failed");
-    clack.outro(chalk5.red(`Error: ${error}`));
+    clack.outro(chalk8.red(`Error: ${error}`));
   }
 }
 async function widgetFlow() {
@@ -1448,14 +1890,14 @@ async function widgetFlow() {
   const ds = detectDesignSystem(projectRoot);
   if (!ds) {
     clack.outro(
-      chalk5.red(
+      chalk8.red(
         "No design system detected. Run this command from a project with wl_design_system/ directory."
       )
     );
     return;
   }
   clack.log.info(
-    `Design system: ${chalk5.cyan(path9.relative(projectRoot, ds.componentsDir))}`
+    `Design system: ${chalk8.cyan(path12.relative(projectRoot, ds.componentsDir))}`
   );
   const name = await clack.text({
     message: "Widget name (snake_case, without wl_ prefix)",
@@ -1520,17 +1962,17 @@ async function widgetFlow() {
         genSpinner.stop(`Use-case skipped: ${e}`);
       }
     }
-    clack.outro(chalk5.green("Done!"));
+    clack.outro(chalk8.green("Done!"));
   } catch (error) {
     genSpinner.stop("Failed");
-    clack.outro(chalk5.red(`Error: ${error}`));
+    clack.outro(chalk8.red(`Error: ${error}`));
   }
 }
-async function useCaseFlow(project) {
-  const ds = detectDesignSystem(project.projectRoot);
+async function useCaseFlow() {
+  const ds = detectDesignSystem(process.cwd());
   if (!ds) {
     clack.outro(
-      chalk5.red(
+      chalk8.red(
         "No design system detected. Ensure wl_design_system/ directory exists."
       )
     );
@@ -1538,7 +1980,7 @@ async function useCaseFlow(project) {
   }
   if (!ds.widgetbookDir) {
     clack.outro(
-      chalk5.red(
+      chalk8.red(
         "No widgetbook package detected. Ensure apps/widgetbook/ exists."
       )
     );
@@ -1583,22 +2025,22 @@ async function useCaseFlow(project) {
   genSpinner.start("Generating use-case file...");
   try {
     await createUseCase(name, tier, {
-      projectRoot: project.projectRoot,
+      projectRoot: process.cwd(),
       buildRunner: runBuildRunner2
     });
     genSpinner.stop("Use-case generated");
-    clack.outro(chalk5.green("Done!"));
+    clack.outro(chalk8.green("Done!"));
   } catch (error) {
     genSpinner.stop("Failed");
-    clack.outro(chalk5.red(`Error: ${error}`));
+    clack.outro(chalk8.red(`Error: ${error}`));
   }
 }
 function findBffFiles(dir) {
   const results = [];
-  if (!fs10.existsSync(dir)) return results;
-  const entries = fs10.readdirSync(dir, { withFileTypes: true });
+  if (!fs13.existsSync(dir)) return results;
+  const entries = fs13.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path9.join(dir, entry.name);
+    const fullPath = path12.join(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...findBffFiles(fullPath));
     } else if (entry.isFile() && entry.name.endsWith(".dart") && !entry.name.includes(".g.")) {
@@ -1610,8 +2052,8 @@ function findBffFiles(dir) {
 function inferBffFile(bffFiles, endpointPath) {
   const firstSegment = endpointPath.replace(/^\//, "").split("/")[0].toLowerCase();
   if (!firstSegment) return null;
-  const withDomains = bffFiles.map((f) => {
-    const base = path9.basename(f, ".dart");
+  const withDomains = bffFiles.filter((f) => /^bff_.+_api\.dart$/.test(path12.basename(f))).map((f) => {
+    const base = path12.basename(f, ".dart");
     const domain = base.replace(/^bff_/, "").replace(/_api$/, "");
     return { file: f, domain };
   });
@@ -1635,42 +2077,68 @@ async function resolveEndpointProject() {
   s.start("Finding BFF package...");
   const monorepoRoot = findMonorepoRoot(process.cwd());
   if (monorepoRoot) {
+    s.message(`Monorepo found at ${monorepoRoot}`);
     const packageBases = ["packages", "packages/features"];
     for (const base of packageBases) {
-      const baseDir = path9.join(monorepoRoot, base);
-      if (!fs10.existsSync(baseDir)) continue;
-      const entries = fs10.readdirSync(baseDir, { withFileTypes: true });
+      const baseDir = path12.join(monorepoRoot, base);
+      if (!fs13.existsSync(baseDir)) continue;
+      const entries = fs13.readdirSync(baseDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        const candidate = path9.join(baseDir, entry.name);
-        if (!fs10.existsSync(path9.join(candidate, "pubspec.yaml"))) continue;
-        if (fs10.existsSync(path9.join(candidate, "lib", "data", "api", "bff"))) {
-          const project = analyzeProject(candidate);
-          if (project) {
-            s.stop(`Using ${chalk5.green(project.projectName)}`);
-            return project;
+        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 project2 = analyzeProject(candidate);
+          if (project2) {
+            s.stop(`Using ${chalk8.green(project2.projectName)}`);
+            return project2;
           }
         }
       }
     }
+  } else {
+    s.message("No monorepo root found");
   }
   const cwdProject = analyzeProject(process.cwd());
-  if (cwdProject && fs10.existsSync(path9.join(cwdProject.projectRoot, "lib", "data", "api", "bff"))) {
-    s.stop(`Using ${chalk5.green(cwdProject.projectName)}`);
+  if (cwdProject && fs13.existsSync(path12.join(cwdProject.projectRoot, "lib", "data", "api", "bff"))) {
+    s.stop(`Using ${chalk8.green(cwdProject.projectName)}`);
     return cwdProject;
   }
   s.stop("No BFF package found");
-  clack.outro(chalk5.red("Could not find a package with lib/data/api/bff/."));
-  return null;
+  const manualPath = await clack.text({
+    message: "Enter the path to the package (must contain lib/data/api/bff/):",
+    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";
+    }
+  });
+  if (clack.isCancel(manualPath)) {
+    clack.cancel("Cancelled");
+    return null;
+  }
+  const resolved = path12.resolve(manualPath);
+  const project = analyzeProject(resolved);
+  if (!project) {
+    clack.outro(chalk8.red(`Could not analyze project at ${resolved}`));
+    return null;
+  }
+  clack.log.info(`Using ${chalk8.green(project.projectName)}`);
+  return project;
 }
 async function endpointFlow() {
   const project = await resolveEndpointProject();
   if (!project) return;
-  const lib = path9.join(project.projectRoot, "lib");
-  const bffDir = path9.join(lib, "data", "api", "bff");
+  const lib = path12.join(project.projectRoot, "lib");
+  const bffDir = path12.join(lib, "data", "api", "bff");
   const bffFiles = findBffFiles(bffDir);
   if (bffFiles.length === 0) {
-    clack.outro(chalk5.red("No BFF API files found. Ensure lib/data/api/bff/ exists with .dart files."));
+    clack.outro(chalk8.red("No BFF API files found. Ensure lib/data/api/bff/ exists with .dart files."));
     return;
   }
   const httpMethod = await clack.select({
@@ -1700,13 +2168,13 @@ async function endpointFlow() {
   }
   let bffApiFile = inferBffFile(bffFiles, endpointPath);
   if (bffApiFile) {
-    clack.log.info(`Auto-detected BFF file: ${chalk5.cyan(path9.basename(bffApiFile))}`);
+    clack.log.info(`Auto-detected BFF file: ${chalk8.cyan(path12.basename(bffApiFile))}`);
   } else {
     const selected = await clack.select({
       message: "Could not auto-detect BFF file. Select one:",
       options: bffFiles.map((f) => ({
         value: f,
-        label: path9.relative(bffDir, f)
+        label: path12.relative(bffDir, f)
       }))
     });
     if (clack.isCancel(selected)) {
@@ -1731,6 +2199,31 @@ async function endpointFlow() {
     clack.cancel("Cancelled");
     return;
   }
+  const diTarget = await clack.select({
+    message: "Where to register DI modules?",
+    options: [
+      { value: "app_base", label: "app_base" },
+      { value: "app_base_loyalty", label: "app_base_loyalty" },
+      { value: "none", label: "Skip (no DI registration)" }
+    ],
+    initialValue: "app_base"
+  });
+  if (clack.isCancel(diTarget)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  let diLazySingleton = true;
+  if (diTarget !== "none") {
+    const lazyAnswer = await clack.confirm({
+      message: "Use @lazySingleton annotation?",
+      initialValue: true
+    });
+    if (clack.isCancel(lazyAnswer)) {
+      clack.cancel("Cancelled");
+      return;
+    }
+    diLazySingleton = lazyAnswer;
+  }
   const genSpinner = clack.spinner();
   genSpinner.start("Generating endpoint stack...");
   try {
@@ -1740,17 +2233,71 @@ async function endpointFlow() {
       httpMethod,
       endpointPath,
       bffApiFile,
-      useCaseName
+      useCaseName,
+      diTarget,
+      diLazySingleton
     });
     genSpinner.stop("Endpoint generated");
-    clack.outro(chalk5.green("Done!"));
+    clack.outro(chalk8.green("Done!"));
   } catch (error) {
     genSpinner.stop("Failed");
-    clack.outro(chalk5.red(`Error: ${error}`));
+    clack.outro(chalk8.red(`Error: ${error}`));
+  }
+}
+async function docsInteractiveMode() {
+  clack.intro(chalk8.bgCyan(chalk8.black(" wlmaker docs ")));
+  const action = await clack.select({
+    message: "What do you want to do?",
+    options: [
+      { value: "serve", label: "Serve", hint: "Start Docusaurus dev server" },
+      { value: "commands", label: "Commands", hint: "Show Makefile & melos commands" },
+      { value: "architecture", label: "Architecture", hint: "Display monorepo tree" }
+    ]
+  });
+  if (clack.isCancel(action)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  switch (action) {
+    case "serve": {
+      const bookDir = detectBookDir(process.cwd());
+      if (!bookDir) {
+        clack.outro(
+          chalk8.red("No Docusaurus book/ directory found. Run from a monorepo root.")
+        );
+        return;
+      }
+      clack.log.info(`Serving docs from ${chalk8.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."));
+        return;
+      }
+      clack.log.info(`Found ${chalk8.green(commands.length.toString())} command(s)`);
+      displayCommands(commands);
+      clack.outro(chalk8.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.")
+        );
+        return;
+      }
+      displayArchitecture(info);
+      clack.outro(chalk8.green("Done!"));
+      break;
+    }
   }
 }
 async function interactiveMode() {
-  clack.intro(chalk5.bgCyan(chalk5.black(" wlmaker ")));
+  clack.intro(chalk8.bgCyan(chalk8.black(" wlmaker ")));
   const createType = await clack.select({
     message: "What do you want to create?",
     options: [
@@ -1765,6 +2312,11 @@ async function interactiveMode() {
         value: "endpoint",
         label: "Endpoint",
         hint: "BFF Clean Architecture stack"
+      },
+      {
+        value: "docs",
+        label: "Docs",
+        hint: "Project documentation tools"
       }
     ]
   });
@@ -1783,15 +2335,15 @@ async function interactiveMode() {
     case "widget":
       await widgetFlow();
       break;
-    case "usecase": {
-      const project = await resolveProject();
-      if (!project) return;
-      await useCaseFlow(project);
+    case "usecase":
+      await useCaseFlow();
       break;
-    }
     case "endpoint":
       await endpointFlow();
       break;
+    case "docs":
+      await docsInteractiveMode();
+      break;
   }
 }
 
@@ -1811,7 +2363,7 @@ program.command("bloc").description("Create a new BLoC with Freezed sealed class
     try {
       await createBloc(name, options);
     } catch (error) {
-      console.error(chalk6.red(`Error: ${error}`));
+      console.error(chalk9.red(`Error: ${error}`));
       process.exit(1);
     }
   }
@@ -1828,12 +2380,12 @@ program.command("widget").description("Create a new widget in the design system"
           projectRoot: options.dir,
           buildRunner: false
         });
-        console.log(chalk6.green("Widgetbook use-case created"));
+        console.log(chalk9.green("Widgetbook use-case created"));
       } catch {
-        console.log(chalk6.yellow("Use-case skipped (may already exist)"));
+        console.log(chalk9.yellow("Use-case skipped (may already exist)"));
       }
     } catch (error) {
-      console.error(chalk6.red(`Error: ${error}`));
+      console.error(chalk9.red(`Error: ${error}`));
       process.exit(1);
     }
   }
@@ -1846,7 +2398,7 @@ program.command("usecase").description("Create a Widgetbook use-case for an exis
         buildRunner: options.buildRunner
       });
     } catch (error) {
-      console.error(chalk6.red(`Error: ${error}`));
+      console.error(chalk9.red(`Error: ${error}`));
       process.exit(1);
     }
   }
@@ -1856,6 +2408,37 @@ program.command("endpoint").description("Generate Clean Architecture stack for a
   if (!project) return;
   await endpointFlow(project);
 });
+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."));
+    process.exit(1);
+  }
+  console.log(chalk9.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."));
+    return;
+  }
+  console.log(chalk9.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."));
+    return;
+  }
+  displayArchitecture(info);
+});
+docsCmd.action(async () => {
+  await docsInteractiveMode();
+});
 program.action(async () => {
   await interactiveMode();
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wlmaker",
-  "version": "1.2.12",
+  "version": "1.3.0",
   "description": "Create Flutter BLoCs with Freezed sealed classes from the terminal",
   "keywords": [
     "flutter",
@@ -16,7 +16,8 @@
   },
   "license": "MIT",
   "bin": {
-    "wlmaker": "./dist/cli.mjs"
+    "wlmaker": "./dist/cli.mjs",
+    "wl": "./dist/cli.mjs"
   },
   "files": [
     "dist"