wlmaker 1.2.13 → 1.3.1

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,11 +956,12 @@ 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 { execSync } from "child_process";
 import * as clack from "@clack/prompts";
-import chalk5 from "chalk";
+import chalk8 from "chalk";
 
 // src/core/create-endpoint.ts
 import * as fs9 from "fs";
@@ -1049,8 +1050,8 @@ ${paramsClass}
 }
 `;
 }
-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}`;
@@ -1464,6 +1465,289 @@ function injectModuleRegistration(filePath, className, registrationCode, dedupKe
   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_]*$/;
 async function resolveProject() {
@@ -1471,7 +1755,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...");
@@ -1484,8 +1768,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)`);
@@ -1493,12 +1777,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({
@@ -1506,7 +1790,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)) {
@@ -1554,13 +1838,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.",
@@ -1577,7 +1861,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({
@@ -1596,10 +1880,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() {
@@ -1607,14 +1891,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)",
@@ -1679,17 +1963,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() {
   const ds = detectDesignSystem(process.cwd());
   if (!ds) {
     clack.outro(
-      chalk5.red(
+      chalk8.red(
         "No design system detected. Ensure wl_design_system/ directory exists."
       )
     );
@@ -1697,7 +1981,7 @@ async function useCaseFlow() {
   }
   if (!ds.widgetbookDir) {
     clack.outro(
-      chalk5.red(
+      chalk8.red(
         "No widgetbook package detected. Ensure apps/widgetbook/ exists."
       )
     );
@@ -1746,18 +2030,18 @@ async function useCaseFlow() {
       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.")) {
@@ -1769,8 +2053,8 @@ function findBffFiles(dir) {
 function inferBffFile(bffFiles, endpointPath) {
   const firstSegment = endpointPath.replace(/^\//, "").split("/")[0].toLowerCase();
   if (!firstSegment) return null;
-  const withDomains = bffFiles.filter((f) => /^bff_.+_api\.dart$/.test(path9.basename(f))).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 };
   });
@@ -1797,19 +2081,19 @@ async function resolveEndpointProject() {
     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;
-        const bffPath = path9.join(candidate, "lib", "data", "api", "bff");
-        s.message(`Checking ${candidate} \u2192 bff exists: ${fs10.existsSync(bffPath)}`);
-        if (fs10.existsSync(bffPath)) {
+        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 ${chalk5.green(project2.projectName)}`);
+            s.stop(`Using ${chalk8.green(project2.projectName)}`);
             return project2;
           }
         }
@@ -1819,8 +2103,8 @@ async function resolveEndpointProject() {
     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");
@@ -1829,33 +2113,33 @@ async function resolveEndpointProject() {
     placeholder: "e.g. /path/to/my-package or ./packages/core",
     validate: (v) => {
       if (!v.trim()) return "Path is required";
-      const resolved2 = path9.resolve(v.trim());
-      if (!fs10.existsSync(resolved2)) return "Path does not exist";
-      if (!fs10.existsSync(path9.join(resolved2, "pubspec.yaml"))) return "No pubspec.yaml found at this path";
-      if (!fs10.existsSync(path9.join(resolved2, "lib", "data", "api", "bff"))) return "No lib/data/api/bff/ found at this path";
+      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 = path9.resolve(manualPath);
+  const resolved = path12.resolve(manualPath);
   const project = analyzeProject(resolved);
   if (!project) {
-    clack.outro(chalk5.red(`Could not analyze project at ${resolved}`));
+    clack.outro(chalk8.red(`Could not analyze project at ${resolved}`));
     return null;
   }
-  clack.log.info(`Using ${chalk5.green(project.projectName)}`);
+  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({
@@ -1885,13 +2169,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)) {
@@ -1955,14 +2239,99 @@ async function endpointFlow() {
       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 serveMode = await clack.select({
+        message: "How do you want to view the docs?",
+        options: [
+          { value: "local", label: "Local", hint: "Start Docusaurus dev server locally" },
+          { value: "remote", label: "Remote", hint: "Open the deployed docs in your browser" }
+        ]
+      });
+      if (clack.isCancel(serveMode)) {
+        clack.cancel("Cancelled");
+        return;
+      }
+      if (serveMode === "remote") {
+        const challenge = await clack.text({
+          message: "Pregunta de seguridad: Qu\xE9 dice mechi cuando tiene una duda en el dise\xF1o?",
+          placeholder: "...",
+          validate: (input) => {
+            const normalized = input.trim().toLowerCase().replace(/[áä]/g, "a").replace(/[éë]/g, "e").replace(/[íï]/g, "i").replace(/[óö]/g, "o").replace(/[úü]/g, "u");
+            const expected = "deja le pregunto a cesita";
+            if (normalized !== expected) {
+              return "Respuesta incorrecta. Vuelve cuando sepas el lore.";
+            }
+          }
+        });
+        if (clack.isCancel(challenge)) {
+          clack.cancel("Cancelled");
+          return;
+        }
+        const remoteUrl = "https://dc-wl-docs.web.app/development_workflow/";
+        clack.log.info(`Opening remote docs: ${chalk8.cyan(remoteUrl)}`);
+        execSync(`open "${remoteUrl}"`, { stdio: "ignore" });
+        clack.outro(chalk8.green("Opened remote docs in browser"));
+        return;
+      }
+      const bookDir = detectBookDir(process.cwd());
+      if (!bookDir) {
+        clack.outro(
+          chalk8.red("No Docusaurus book/ directory found. Run from a monorepo root.")
+        );
+        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: [
@@ -1977,6 +2346,11 @@ async function interactiveMode() {
         value: "endpoint",
         label: "Endpoint",
         hint: "BFF Clean Architecture stack"
+      },
+      {
+        value: "docs",
+        label: "Docs",
+        hint: "Project documentation tools"
       }
     ]
   });
@@ -2001,6 +2375,9 @@ async function interactiveMode() {
     case "endpoint":
       await endpointFlow();
       break;
+    case "docs":
+      await docsInteractiveMode();
+      break;
   }
 }
 
@@ -2020,7 +2397,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);
     }
   }
@@ -2037,12 +2414,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);
     }
   }
@@ -2055,7 +2432,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);
     }
   }
@@ -2065,6 +2442,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.13",
+  "version": "1.3.1",
   "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"