wlmaker 1.4.1 → 1.6.0

package/dist/cli.mjs

@@ -1,9 +1,12 @@
 #!/usr/bin/env node
+import {
+  installMcpServer
+} from "./chunk-OXBECDQE.mjs";
 
 // src/cli.ts
 import { createRequire } from "module";
 import { Command } from "commander";
-import chalk10 from "chalk";
+import chalk12 from "chalk";
 
 // src/core/create-bloc.ts
 import * as fs3 from "fs";
@@ -106,17 +109,17 @@ function hasBuildRunner(projectRoot) {
   return /build_runner/.test(pubspec);
 }
 function runBuildRunner(projectRoot) {
-  return new Promise((resolve4) => {
+  return new Promise((resolve5) => {
     const child = spawn(
       "dart",
       ["run", "build_runner", "build", "--delete-conflicting-outputs"],
       { cwd: projectRoot, stdio: "inherit" }
     );
     child.on("close", (code) => {
-      resolve4();
+      resolve5();
     });
     child.on("error", () => {
-      resolve4();
+      resolve5();
     });
   });
 }
@@ -955,19 +958,154 @@ async function createUseCase(name, tierInput, options) {
   }
 }
 
+// src/core/create-page.ts
+import * as fs8 from "fs";
+import * as path8 from "path";
+import chalk4 from "chalk";
+
+// src/core/page-templates.ts
+import { pascalCase as pascalCase4 } from "change-case";
+function pageTemplate(name, packageName) {
+  const pascal = pascalCase4(name);
+  const routePath = "/" + name;
+  const imports = [
+    `package:flutter/material.dart`,
+    `package:go_router/go_router.dart`,
+    `package:${packageName}/pages/views/${name}_view.dart`
+  ].sort();
+  return `${imports.map((i) => `import '${i}';`).join("\n")}
+
+class ${pascal}Page extends GoRoute {
+  ${pascal}Page({super.name, super.routes})
+      : super(
+          path: fullPath,
+          pageBuilder: (context, state) =>
+              const MaterialPage(child: ${pascal}View()),
+        );
+
+  static const fullPath = '${routePath}';
+
+  static void open(BuildContext context) => context.go(fullPath);
+}
+`;
+}
+function viewTemplate(name) {
+  const pascal = pascalCase4(name);
+  return `import 'package:flutter/material.dart';
+
+class ${pascal}View extends StatelessWidget {
+  const ${pascal}View({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(title: const Text('${pascal}')),
+      body: const Center(child: Text('${pascal}')),
+    );
+  }
+}
+`;
+}
+
+// src/core/create-page.ts
+var SNAKE_CASE_REGEX4 = /^[a-z][a-z0-9_]*$/;
+async function createPage(name, options) {
+  const pagesPath = path8.resolve(options.pagesPath);
+  if (!name || name.trim().length === 0) {
+    throw new Error("Page name is required.");
+  }
+  if (!SNAKE_CASE_REGEX4.test(name)) {
+    throw new Error("Page name must be snake_case (lowercase letters, digits, underscores).");
+  }
+  if (!fs8.existsSync(pagesPath)) {
+    throw new Error(`Path does not exist: ${pagesPath}`);
+  }
+  const packageName = extractPackageName(pagesPath);
+  const pageFile = path8.join(pagesPath, `${name}_page.dart`);
+  const viewsDir = path8.join(pagesPath, "views");
+  const viewFile = path8.join(viewsDir, `${name}_view.dart`);
+  if (fs8.existsSync(pageFile)) {
+    throw new Error(`Page "${name}" already exists at ${pageFile}`);
+  }
+  if (fs8.existsSync(viewFile)) {
+    throw new Error(`View "${name}" already exists at ${viewFile}`);
+  }
+  fs8.mkdirSync(viewsDir, { recursive: true });
+  if (!packageName) {
+    throw new Error(
+      `Could not determine package name from path: ${pagesPath}
+Expected path pattern: .../packages/<name>/lib/pages`
+    );
+  }
+  fs8.writeFileSync(pageFile, pageTemplate(name, packageName));
+  console.log(chalk4.green(`  \u2713 Page file created: ${pageFile}`));
+  fs8.writeFileSync(viewFile, viewTemplate(name));
+  console.log(chalk4.green(`  \u2713 View file created: ${viewFile}`));
+  updateViewsBarrel(viewsDir, name);
+  updatePagesBarrel(pagesPath, name);
+}
+function updateViewsBarrel(viewsDir, name) {
+  const barrelPath = path8.join(viewsDir, "views.dart");
+  const exportLine = `export '${name}_view.dart';`;
+  let lines = [];
+  if (fs8.existsSync(barrelPath)) {
+    const content = fs8.readFileSync(barrelPath, "utf8");
+    lines = content.split("\n").filter((l) => l.trim().length > 0);
+  }
+  if (lines.includes(exportLine)) {
+    console.log(chalk4.blue("  \xB7 Export already in views.dart"));
+    return;
+  }
+  lines.push(exportLine);
+  lines.sort();
+  fs8.writeFileSync(barrelPath, lines.join("\n") + "\n");
+  console.log(chalk4.green("  \u2713 views.dart updated"));
+}
+function updatePagesBarrel(pagesPath, name) {
+  const barrelPath = path8.join(pagesPath, "pages.dart");
+  const pageExport = `export '${name}_page.dart';`;
+  const viewsExport = `export 'views/views.dart';`;
+  let lines = [];
+  if (fs8.existsSync(barrelPath)) {
+    const content = fs8.readFileSync(barrelPath, "utf8");
+    lines = content.split("\n").filter((l) => l.trim().length > 0);
+  }
+  let modified = false;
+  if (!lines.includes(pageExport)) {
+    lines.push(pageExport);
+    modified = true;
+  }
+  if (!lines.includes(viewsExport)) {
+    lines.push(viewsExport);
+    modified = true;
+  }
+  if (modified) {
+    lines.sort();
+    fs8.writeFileSync(barrelPath, lines.join("\n") + "\n");
+    console.log(chalk4.green("  \u2713 pages.dart updated"));
+  } else {
+    console.log(chalk4.blue("  \xB7 pages.dart already up to date"));
+  }
+}
+function extractPackageName(pagesPath) {
+  const normalized = pagesPath.replace(/\\/g, "/");
+  const match = normalized.match(/\/([^/]+)\/lib\/pages\/?$/);
+  return match ? match[1] : null;
+}
+
 // src/interactive.ts
-import * as fs14 from "fs";
+import * as fs16 from "fs";
 import * as os from "os";
-import * as path13 from "path";
-import { execSync as execSync2 } from "child_process";
+import * as path15 from "path";
+import { execSync as execSync3 } from "child_process";
 import * as clack from "@clack/prompts";
-import chalk9 from "chalk";
+import chalk11 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 as camelCase2 } from "change-case";
+import * as fs10 from "fs";
+import * as path9 from "path";
+import chalk5 from "chalk";
+import { pascalCase as pascalCase5, camelCase as camelCase2 } from "change-case";
 
 // src/core/endpoint-templates.ts
 import { camelCase } from "change-case";
@@ -1050,8 +1188,8 @@ ${paramsClass}
 }
 `;
 }
-function retrofitMethod(methodName, path14, httpMethod, params, returnType) {
-  const httpAnnotation = `@${httpMethod.toUpperCase()}('${path14}')`;
+function retrofitMethod(methodName, path16, httpMethod, params, returnType) {
+  const httpAnnotation = `@${httpMethod.toUpperCase()}('${path16}')`;
   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}`;
@@ -1117,9 +1255,9 @@ ${annotation}${useCaseClass} ${useCaseCamel}(${repoInterface} repository) =>
 }
 
 // src/core/dart-injector.ts
-import * as fs8 from "fs";
+import * as fs9 from "fs";
 function injectMethod(filePath, className, methodCode, dedupKey) {
-  const content = fs8.readFileSync(filePath, "utf8");
+  const content = fs9.readFileSync(filePath, "utf8");
   const dedup = dedupKey ?? findSignature(methodCode);
   if (dedup && content.includes(dedup)) {
     return;
@@ -1150,10 +1288,10 @@ function injectMethod(filePath, className, methodCode, dedupKey) {
   }
   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);
+  fs9.writeFileSync(filePath, newContent);
 }
 function injectImport(filePath, importLine) {
-  const content = fs8.readFileSync(filePath, "utf8");
+  const content = fs9.readFileSync(filePath, "utf8");
   if (content.includes(importLine.trim())) {
     return;
   }
@@ -1163,15 +1301,15 @@ function injectImport(filePath, importLine) {
     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);
+    fs9.writeFileSync(filePath, newContent);
   } else {
-    fs8.writeFileSync(filePath, importLine + "\n\n" + content);
+    fs9.writeFileSync(filePath, importLine + "\n\n" + content);
   }
 }
 function injectExport(filePath, exportLine) {
   let content = "";
-  if (fs8.existsSync(filePath)) {
-    content = fs8.readFileSync(filePath, "utf8");
+  if (fs9.existsSync(filePath)) {
+    content = fs9.readFileSync(filePath, "utf8");
   }
   if (content.includes(exportLine)) {
     return;
@@ -1179,7 +1317,7 @@ function injectExport(filePath, exportLine) {
   const lines = content.split("\n").filter((l) => l.trim().length > 0);
   lines.push(exportLine);
   lines.sort();
-  fs8.writeFileSync(filePath, lines.join("\n") + "\n");
+  fs9.writeFileSync(filePath, lines.join("\n") + "\n");
 }
 function findSignature(methodCode) {
   const lines = methodCode.trim().split("\n");
@@ -1194,51 +1332,51 @@ function findSignature(methodCode) {
 
 // src/core/create-endpoint.ts
 async function createEndpoint(options) {
-  const lib = path8.join(options.projectRoot, "lib");
-  const pascal = pascalCase4(options.useCaseName);
-  const useCasePascal = pascalCase4(options.useCaseName);
+  const lib = path9.join(options.projectRoot, "lib");
+  const pascal = pascalCase5(options.useCaseName);
+  const useCasePascal = pascalCase5(options.useCaseName);
   const useCaseSnake = options.useCaseName;
   const needsBody = ["POST", "PUT", "PATCH"].includes(options.httpMethod);
   const domain = extractDomain(options.bffApiFile);
-  const datasourceFile = path8.join(lib, "data", "datasources", `${domain}_rest_datasource.dart`);
-  const datasourceClassName = `${pascalCase4(domain)}RestDataSource`;
-  const repositoryInterfaceFile = path8.join(lib, "domain", "repositories", `${domain}_repository.dart`);
-  const repositoryInterfaceName = `${pascalCase4(domain)}Repository`;
-  const repositoryImplFile = path8.join(lib, "data", "repositories", `${domain}_repository_data.dart`);
-  const repositoryImplClassName = `${pascalCase4(domain)}RepositoryData`;
+  const datasourceFile = path9.join(lib, "data", "datasources", `${domain}_rest_datasource.dart`);
+  const datasourceClassName = `${pascalCase5(domain)}RestDataSource`;
+  const repositoryInterfaceFile = path9.join(lib, "domain", "repositories", `${domain}_repository.dart`);
+  const repositoryInterfaceName = `${pascalCase5(domain)}Repository`;
+  const repositoryImplFile = path9.join(lib, "data", "repositories", `${domain}_repository_data.dart`);
+  const repositoryImplClassName = `${pascalCase5(domain)}RepositoryData`;
   const feature = domain;
   const pathParams = extractPathParams(options.endpointPath);
   const methodParams = buildMethodParams(options, pathParams, needsBody);
   const methodParamsForSignature = methodParams.map((p) => ({ name: p.name, type: p.type }));
   const modelType = `${pascal}Model`;
   const entityType = `${pascal}Entity`;
-  const spinner3 = (msg) => console.log(chalk4.cyan(`  \u2192 ${msg}`));
+  const spinner3 = (msg) => console.log(chalk5.cyan(`  \u2192 ${msg}`));
   spinner3("Generating entity");
-  const entityDir = path8.join(lib, "domain", "entities", feature);
-  fs9.mkdirSync(entityDir, { recursive: true });
-  fs9.writeFileSync(
-    path8.join(entityDir, `${useCaseSnake}_entity.dart`),
+  const entityDir = path9.join(lib, "domain", "entities", feature);
+  fs10.mkdirSync(entityDir, { recursive: true });
+  fs10.writeFileSync(
+    path9.join(entityDir, `${useCaseSnake}_entity.dart`),
     entityBoilerplate(pascal)
   );
   spinner3("Generating model");
-  const modelDir = path8.join(lib, "data", "models", feature);
-  fs9.mkdirSync(modelDir, { recursive: true });
-  fs9.writeFileSync(
-    path8.join(modelDir, `${useCaseSnake}_model.dart`),
+  const modelDir = path9.join(lib, "data", "models", feature);
+  fs10.mkdirSync(modelDir, { recursive: true });
+  fs10.writeFileSync(
+    path9.join(modelDir, `${useCaseSnake}_model.dart`),
     modelBoilerplate(useCaseSnake, pascal, options.projectName)
   );
   if (needsBody) {
     spinner3("Generating request model");
-    const reqModelDir = path8.join(lib, "data", "models", feature);
-    fs9.mkdirSync(reqModelDir, { recursive: true });
-    fs9.writeFileSync(
-      path8.join(reqModelDir, `${useCaseSnake}_request_model.dart`),
+    const reqModelDir = path9.join(lib, "data", "models", feature);
+    fs10.mkdirSync(reqModelDir, { recursive: true });
+    fs10.writeFileSync(
+      path9.join(reqModelDir, `${useCaseSnake}_request_model.dart`),
       requestModelBoilerplate(useCaseSnake, pascal)
     );
   }
   spinner3("Injecting Retrofit method");
-  const bffPath = path8.resolve(options.bffApiFile);
-  if (fs9.existsSync(bffPath)) {
+  const bffPath = path9.resolve(options.bffApiFile);
+  if (fs10.existsSync(bffPath)) {
     const retrofitParams = buildRetrofitParams(options, pathParams, needsBody);
     const method = retrofitMethod(
       camelCase2(options.useCaseName),
@@ -1249,11 +1387,11 @@ async function createEndpoint(options) {
     );
     injectMethod(bffPath, extractClassName(bffPath), method);
   } else {
-    console.log(chalk4.yellow(`  \u26A0 BFF API file not found: ${bffPath}`));
+    console.log(chalk5.yellow(`  \u26A0 BFF API file not found: ${bffPath}`));
   }
   spinner3("Injecting datasource method");
-  const dsPath = path8.resolve(datasourceFile);
-  if (fs9.existsSync(dsPath)) {
+  const dsPath = path9.resolve(datasourceFile);
+  if (fs10.existsSync(dsPath)) {
     const dsMethod = datasourceMethod(
       camelCase2(options.useCaseName),
       modelType,
@@ -1261,11 +1399,11 @@ async function createEndpoint(options) {
     );
     injectMethod(dsPath, datasourceClassName, dsMethod);
   } else {
-    console.log(chalk4.yellow(`  \u26A0 Datasource file not found: ${dsPath}`));
+    console.log(chalk5.yellow(`  \u26A0 Datasource file not found: ${dsPath}`));
   }
   spinner3("Injecting repository interface method");
-  const repoIfacePath = path8.resolve(repositoryInterfaceFile);
-  if (fs9.existsSync(repoIfacePath)) {
+  const repoIfacePath = path9.resolve(repositoryInterfaceFile);
+  if (fs10.existsSync(repoIfacePath)) {
     const ifaceMethod = repositoryInterfaceMethod(
       camelCase2(options.useCaseName),
       entityType,
@@ -1273,11 +1411,11 @@ async function createEndpoint(options) {
     );
     injectMethod(repoIfacePath, repositoryInterfaceName, ifaceMethod);
   } else {
-    console.log(chalk4.yellow(`  \u26A0 Repository interface not found: ${repoIfacePath}`));
+    console.log(chalk5.yellow(`  \u26A0 Repository interface not found: ${repoIfacePath}`));
   }
   spinner3("Injecting repository implementation method");
-  const repoImplPath = path8.resolve(repositoryImplFile);
-  if (fs9.existsSync(repoImplPath)) {
+  const repoImplPath = path9.resolve(repositoryImplFile);
+  if (fs10.existsSync(repoImplPath)) {
     const dsVarName = camelCase2(datasourceClassName);
     const implMethod = repositoryImplMethod(
       camelCase2(options.useCaseName),
@@ -1288,13 +1426,13 @@ async function createEndpoint(options) {
     );
     injectMethod(repoImplPath, repositoryImplClassName, implMethod);
   } else {
-    console.log(chalk4.yellow(`  \u26A0 Repository implementation not found: ${repoImplPath}`));
+    console.log(chalk5.yellow(`  \u26A0 Repository implementation not found: ${repoImplPath}`));
   }
   spinner3("Generating UseCase");
-  const useCaseDir = path8.join(lib, "domain", "usecases", feature);
-  fs9.mkdirSync(useCaseDir, { recursive: true });
-  fs9.writeFileSync(
-    path8.join(useCaseDir, `${useCaseSnake}_usecase.dart`),
+  const useCaseDir = path9.join(lib, "domain", "usecases", feature);
+  fs10.mkdirSync(useCaseDir, { recursive: true });
+  fs10.writeFileSync(
+    path9.join(useCaseDir, `${useCaseSnake}_usecase.dart`),
     useCaseTemplate2(
       useCasePascal,
       camelCase2(options.useCaseName),
@@ -1305,39 +1443,39 @@ async function createEndpoint(options) {
     )
   );
   spinner3("Updating barrel files");
-  const dsFileName = path8.basename(datasourceFile);
+  const dsFileName = path9.basename(datasourceFile);
   injectExport(
-    path8.join(lib, "data", "datasources", "datasources.dart"),
+    path9.join(lib, "data", "datasources", "datasources.dart"),
     `export '${dsFileName}';`
   );
-  const entityBarrel = path8.join(lib, "domain", "entities", feature, `${feature}.dart`);
+  const entityBarrel = path9.join(lib, "domain", "entities", feature, `${feature}.dart`);
   injectExport(entityBarrel, `export '${useCaseSnake}_entity.dart';`);
   injectExport(
-    path8.join(lib, "domain", "entities", "entities.dart"),
+    path9.join(lib, "domain", "entities", "entities.dart"),
     `export '${feature}/${feature}.dart';`
   );
-  const modelBarrel = path8.join(lib, "data", "models", feature, `${feature}.dart`);
+  const modelBarrel = path9.join(lib, "data", "models", feature, `${feature}.dart`);
   injectExport(modelBarrel, `export '${useCaseSnake}_model.dart';`);
   if (needsBody) {
     injectExport(modelBarrel, `export '${useCaseSnake}_request_model.dart';`);
   }
   injectExport(
-    path8.join(lib, "data", "models", "models.dart"),
+    path9.join(lib, "data", "models", "models.dart"),
     `export '${feature}/${feature}.dart';`
   );
-  const useCaseBarrel = path8.join(useCaseDir, `${feature}.dart`);
+  const useCaseBarrel = path9.join(useCaseDir, `${feature}.dart`);
   injectExport(useCaseBarrel, `export '${useCaseSnake}_usecase.dart';`);
   injectExport(
-    path8.join(lib, "domain", "usecases", "usecases.dart"),
+    path9.join(lib, "domain", "usecases", "usecases.dart"),
     `export '${feature}/${feature}.dart';`
   );
   if (options.diTarget && options.diTarget !== "none") {
     spinner3("Registering in DI modules");
     const appBaseDir = findAppBasePackageDir(options.projectRoot, options.diTarget);
     if (appBaseDir) {
-      const domainPascal = pascalCase4(domain);
+      const domainPascal = pascalCase5(domain);
       const lazy = options.diLazySingleton !== false;
-      const dsModuleFile = path8.join(appBaseDir, "datasources_module.dart");
+      const dsModuleFile = path9.join(appBaseDir, "datasources_module.dart");
       const dsRegistration = datasourceModuleRegistration(domainPascal, lazy);
       injectModuleRegistration(
         dsModuleFile,
@@ -1345,7 +1483,7 @@ async function createEndpoint(options) {
         dsRegistration,
         `${domainPascal}RestDataSource`
       );
-      const repoModuleFile = path8.join(appBaseDir, "repositories_module.dart");
+      const repoModuleFile = path9.join(appBaseDir, "repositories_module.dart");
       const repoRegistration = repositoryModuleRegistration(domainPascal, lazy);
       injectModuleRegistration(
         repoModuleFile,
@@ -1353,7 +1491,7 @@ async function createEndpoint(options) {
         repoRegistration,
         `${domainPascal}RepositoryData`
       );
-      const ucModuleFile = path8.join(appBaseDir, "usecases_module.dart");
+      const ucModuleFile = path9.join(appBaseDir, "usecases_module.dart");
       const ucRegistration = useCaseModuleRegistration(useCasePascal, domainPascal, lazy);
       injectModuleRegistration(
         ucModuleFile,
@@ -1366,14 +1504,14 @@ async function createEndpoint(options) {
       injectImport(repoModuleFile, coreImport);
       injectImport(ucModuleFile, coreImport);
     } else {
-      console.log(chalk4.yellow(`  \u26A0 Package "${options.diTarget}" not found in monorepo`));
+      console.log(chalk5.yellow(`  \u26A0 Package "${options.diTarget}" not found in monorepo`));
     }
   }
-  console.log(chalk4.green(`
+  console.log(chalk5.green(`
 \u2713 Endpoint "${options.useCaseName}" generated successfully.`));
 }
 function extractDomain(bffApiFile) {
-  const baseName = path8.basename(bffApiFile);
+  const baseName = path9.basename(bffApiFile);
   const match = baseName.match(/^bff_(.+)_api\.dart$/);
   if (match) return match[1];
   return baseName.replace(/\.dart$/, "");
@@ -1390,7 +1528,7 @@ function extractPathParams(endpointPath) {
 function buildMethodParams(options, pathParams, hasRequestBody) {
   const params = [...pathParams];
   if (hasRequestBody) {
-    const reqPascal = pascalCase4(options.useCaseName);
+    const reqPascal = pascalCase5(options.useCaseName);
     params.push({ name: "body", type: `${reqPascal}RequestModel` });
   }
   return params;
@@ -1401,43 +1539,43 @@ function buildRetrofitParams(options, pathParams, hasRequestBody) {
     params.push({ ...pp, isPath: true });
   }
   if (hasRequestBody) {
-    const reqPascal = pascalCase4(options.useCaseName);
+    const reqPascal = pascalCase5(options.useCaseName);
     params.push({ name: "body", type: `${reqPascal}RequestModel`, isBody: true });
   }
   return params;
 }
 function extractClassName(filePath) {
-  const content = fs9.readFileSync(filePath, "utf8");
+  const content = fs10.readFileSync(filePath, "utf8");
   const match = content.match(/class\s+(\w+)\s+/);
   if (!match) throw new Error(`No class found in ${filePath}`);
   return match[1];
 }
 function findAppBasePackageDir(projectRoot, packageName) {
-  let dir = path8.resolve(projectRoot);
+  let dir = path9.resolve(projectRoot);
   for (let i = 0; i < 10; i++) {
-    const candidate = path8.join(dir, "packages", packageName, "lib", "dependencies");
-    if (fs9.existsSync(candidate)) {
+    const candidate = path9.join(dir, "packages", packageName, "lib", "dependencies");
+    if (fs10.existsSync(candidate)) {
       return candidate;
     }
-    const parent = path8.dirname(dir);
+    const parent = path9.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}`));
+  if (!fs10.existsSync(filePath)) {
+    console.log(chalk5.yellow(`  \u26A0 Module file not found: ${filePath}`));
     return;
   }
-  const content = fs9.readFileSync(filePath, "utf8");
+  const content = fs10.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}`));
+    console.log(chalk5.yellow(`  \u26A0 Class "${className}" not found in ${filePath}`));
     return;
   }
   const classStart = content.indexOf(classMatch[0]);
@@ -1457,19 +1595,19 @@ function injectModuleRegistration(filePath, className, registrationCode, dedupKe
     }
   }
   if (classEnd === -1) {
-    console.log(chalk4.yellow(`  \u26A0 Could not find closing brace for "${className}" in ${filePath}`));
+    console.log(chalk5.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);
+  fs10.writeFileSync(filePath, newContent);
 }
 
 // src/core/create-env-var.ts
-import * as fs10 from "fs";
-import * as path9 from "path";
+import * as fs11 from "fs";
+import * as path10 from "path";
 import { execSync } from "child_process";
-import chalk5 from "chalk";
+import chalk6 from "chalk";
 import { camelCase as camelCase3 } from "change-case";
 function screamingSnakeToCamel(name) {
   return camelCase3(name.toLowerCase());
@@ -1557,38 +1695,39 @@ function appConfigModelJsonKey(camelName, dartType) {
   }
 }
 function discoverAppsWithEnv(monorepoRoot) {
-  const appsDir = path9.join(monorepoRoot, "apps");
-  if (!fs10.existsSync(appsDir)) return [];
-  return fs10.readdirSync(appsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).filter((d) => fs10.existsSync(path9.join(appsDir, d.name, "env"))).map((d) => d.name).sort();
+  const appsDir = path10.join(monorepoRoot, "apps");
+  if (!fs11.existsSync(appsDir)) return [];
+  return fs11.readdirSync(appsDir, { withFileTypes: true }).filter((d) => d.isDirectory()).filter((d) => fs11.existsSync(path10.join(appsDir, d.name, "env"))).map((d) => d.name).sort();
 }
 function injectIntoJsonFile(filePath, key, value, isTemplate) {
-  if (!fs10.existsSync(filePath)) {
-    console.log(chalk5.yellow(`  Skipping ${filePath} (not found)`));
-    return;
+  if (!fs11.existsSync(filePath)) {
+    console.log(chalk6.yellow(`  Skipping ${filePath} (not found)`));
+    return null;
   }
-  const content = fs10.readFileSync(filePath, "utf8");
+  const content = fs11.readFileSync(filePath, "utf8");
   const json = JSON.parse(content);
   if (key in json) {
-    console.log(chalk5.yellow(`  Key "${key}" already exists in ${path9.basename(filePath)}`));
-    return;
+    console.log(chalk6.yellow(`  Key "${key}" already exists in ${path10.basename(filePath)}`));
+    return null;
   }
   json[key] = isTemplate ? `\${${key}}` : value;
-  fs10.writeFileSync(filePath, JSON.stringify(json, null, 2) + "\n");
-  console.log(chalk5.green(`  Updated ${path9.basename(filePath)}`));
+  fs11.writeFileSync(filePath, JSON.stringify(json, null, 2) + "\n");
+  console.log(chalk6.green(`  Updated ${path10.basename(filePath)}`));
+  return filePath;
 }
 function injectAbstractGetter(monorepoRoot, camelName, dartType) {
-  const packagesDir = path9.join(monorepoRoot, "packages");
-  if (!fs10.existsSync(packagesDir)) return;
+  const packagesDir = path10.join(monorepoRoot, "packages");
+  if (!fs11.existsSync(packagesDir)) return null;
   const envFile = findFileInPackages(packagesDir, "app_environment.dart");
   if (!envFile) {
-    console.log(chalk5.yellow("  app_environment.dart not found in any package"));
-    return;
+    console.log(chalk6.yellow("  app_environment.dart not found in any package"));
+    return null;
   }
-  const content = fs10.readFileSync(envFile, "utf8");
+  const content = fs11.readFileSync(envFile, "utf8");
   const dedup = `get ${camelName}`;
   if (content.includes(dedup)) {
-    console.log(chalk5.yellow(`  '${camelName}' already in AppEnvironment`));
-    return;
+    console.log(chalk6.yellow(`  '${camelName}' already in AppEnvironment`));
+    return null;
   }
   const getterRegex = /\n\s+\w+(?:<[^>]+>)?\s+get\s+\w+;/g;
   let lastGetterMatch = null;
@@ -1597,43 +1736,46 @@ function injectAbstractGetter(monorepoRoot, camelName, dartType) {
     lastGetterMatch = match;
   }
   if (!lastGetterMatch) {
-    console.log(chalk5.yellow("  No getters found in AppEnvironment"));
-    return;
+    console.log(chalk6.yellow("  No getters found in AppEnvironment"));
+    return null;
   }
   const insertPos = lastGetterMatch.index + lastGetterMatch[0].length;
   const getterLine = `
   ${abstractGetterCode(camelName, dartType)}`;
   const newContent = content.slice(0, insertPos) + getterLine + content.slice(insertPos);
-  fs10.writeFileSync(envFile, newContent);
-  console.log(chalk5.green(`  Injected abstract getter in ${formatPkgPath(monorepoRoot, envFile)}`));
+  fs11.writeFileSync(envFile, newContent);
+  console.log(chalk6.green(`  Injected abstract getter in ${formatPkgPath(monorepoRoot, envFile)}`));
+  return envFile;
 }
 function injectBuildEnvGetter(monorepoRoot, variableName, camelName, dartType) {
-  const packagesDir = path9.join(monorepoRoot, "packages");
-  if (!fs10.existsSync(packagesDir)) return;
+  const packagesDir = path10.join(monorepoRoot, "packages");
+  if (!fs11.existsSync(packagesDir)) return null;
   const buildEnvFile = findFileInPackages(packagesDir, "app_build_environment.dart");
   if (!buildEnvFile) {
-    console.log(chalk5.yellow("  app_build_environment.dart not found in any package"));
-    return;
+    console.log(chalk6.yellow("  app_build_environment.dart not found in any package"));
+    return null;
   }
   const code = buildEnvGetterCode(camelName, variableName, dartType);
   try {
     injectMethod(buildEnvFile, "AppBuildEnvironment", code, `get ${camelName}`);
-    console.log(chalk5.green(`  Injected build env getter in ${formatPkgPath(monorepoRoot, buildEnvFile)}`));
+    console.log(chalk6.green(`  Injected build env getter in ${formatPkgPath(monorepoRoot, buildEnvFile)}`));
+    return buildEnvFile;
   } catch (e) {
-    console.log(chalk5.yellow(`  Skipped: ${e.message}`));
+    console.log(chalk6.yellow(`  Skipped: ${e.message}`));
+    return null;
   }
 }
 function injectIntoRemoteConfigDefaults(vendorsPath, camelName, dartType) {
-  const content = fs10.readFileSync(vendorsPath, "utf8");
+  const content = fs11.readFileSync(vendorsPath, "utf8");
   if (content.includes(`'${camelName}'`) || content.includes(`"${camelName}"`)) {
-    console.log(chalk5.yellow(`  '${camelName}' already in ${path9.basename(vendorsPath)}`));
-    return;
+    console.log(chalk6.yellow(`  '${camelName}' already in ${path10.basename(vendorsPath)}`));
+    return null;
   }
   const defaultValuesRegex = /final\s+defaultValues\s*=\s*(?:<String,\s*dynamic>\s*)?\{/;
   const match = content.match(defaultValuesRegex);
   if (!match) {
-    console.log(chalk5.yellow(`  Could not find defaultValues map in ${path9.basename(vendorsPath)}`));
-    return;
+    console.log(chalk6.yellow(`  Could not find defaultValues map in ${path10.basename(vendorsPath)}`));
+    return null;
   }
   const mapStart = content.indexOf(match[0]) + match[0].length;
   let braceCount = 1;
@@ -1649,8 +1791,8 @@ function injectIntoRemoteConfigDefaults(vendorsPath, camelName, dartType) {
     }
   }
   if (mapEnd === -1) {
-    console.log(chalk5.yellow(`  Could not find end of defaultValues map`));
-    return;
+    console.log(chalk6.yellow(`  Could not find end of defaultValues map`));
+    return null;
   }
   const valueExpr = dartType === "List<String>" ? `jsonEncode(env.${camelName})` : `env.${camelName}`;
   const beforeClose = content.slice(0, mapEnd);
@@ -1667,48 +1809,49 @@ function injectIntoRemoteConfigDefaults(vendorsPath, camelName, dartType) {
   const insertion = `${lastEntryIndent}'${camelName}': ${valueExpr},
 `;
   const newContent = content.slice(0, mapEnd) + insertion + content.slice(mapEnd);
-  fs10.writeFileSync(vendorsPath, newContent);
-  console.log(chalk5.green(`  Injected into VendorsModule defaultValues`));
+  fs11.writeFileSync(vendorsPath, newContent);
+  console.log(chalk6.green(`  Injected into VendorsModule defaultValues`));
+  return vendorsPath;
 }
 function injectAppConfigProperty(configPath, camelName, dartType) {
-  const content = fs10.readFileSync(configPath, "utf8");
+  const content = fs11.readFileSync(configPath, "utf8");
   if (content.includes(`final ${dartTypeForGetter(dartType)} ${camelName}`)) {
-    console.log(chalk5.yellow(`  '${camelName}' already in AppConfig`));
-    return;
+    console.log(chalk6.yellow(`  '${camelName}' already in AppConfig`));
+    return null;
   }
   const fieldLine = `  final ${dartTypeForGetter(dartType)} ${camelName};
 `;
   let newContent = content;
-  const propsMatch = newContent.match(/@override\n\s+List<Object\?>/);
-  if (propsMatch) {
-    const propsPos = newContent.indexOf(propsMatch[0]);
-    newContent = newContent.slice(0, propsPos) + fieldLine + newContent.slice(propsPos);
+  const propsSeparator = newContent.search(/\n\n(\s*)@override\n\s+List<Object\?>/);
+  if (propsSeparator !== -1) {
+    newContent = newContent.slice(0, propsSeparator + 1) + fieldLine + newContent.slice(propsSeparator + 1);
   } else {
     newContent = injectBeforeClassClose(newContent, "AppConfig", `  final ${dartTypeForGetter(dartType)} ${camelName};`);
   }
   newContent = injectConstructorParam(newContent, "AppConfig", camelName, dartType);
   newContent = injectIntoPropsList(newContent, camelName);
-  fs10.writeFileSync(configPath, newContent);
-  console.log(chalk5.green(`  Injected into AppConfig entity`));
+  fs11.writeFileSync(configPath, newContent);
+  console.log(chalk6.green(`  Injected into AppConfig entity`));
+  return configPath;
 }
 function injectAppConfigModelProperty(modelPath, camelName, dartType) {
-  const content = fs10.readFileSync(modelPath, "utf8");
+  const content = fs11.readFileSync(modelPath, "utf8");
   if (content.includes(`final ${dartTypeForGetter(dartType)} ${camelName}`)) {
-    console.log(chalk5.yellow(`  '${camelName}' already in AppConfigModel`));
-    return;
+    console.log(chalk6.yellow(`  '${camelName}' already in AppConfigModel`));
+    return null;
   }
   const jsonKey = appConfigModelJsonKey(camelName, dartType);
-  const fieldLines = jsonKey ? `  ${jsonKey}
+  const fieldLines = jsonKey ? `
+  ${jsonKey}
+  final ${dartTypeForGetter(dartType)} ${camelName};
+` : `
   final ${dartTypeForGetter(dartType)} ${camelName};
-` : `  final ${dartTypeForGetter(dartType)} ${camelName};
 `;
   let newContent = content;
   const staticPos = newContent.search(/\n\s+static\s/);
   const factoryPos = newContent.search(/\n\s+factory\s+AppConfigModel/);
   let insertAnchor = -1;
-  if (staticPos !== -1 && factoryPos !== -1) {
-    insertAnchor = Math.min(staticPos, factoryPos);
-  } else if (staticPos !== -1) {
+  if (staticPos !== -1) {
     insertAnchor = staticPos;
   } else if (factoryPos !== -1) {
     insertAnchor = factoryPos;
@@ -1720,8 +1863,9 @@ function injectAppConfigModelProperty(modelPath, camelName, dartType) {
   }
   newContent = injectConstructorParam(newContent, "AppConfigModel", camelName, dartType);
   newContent = injectIntoSuperCall(newContent, camelName);
-  fs10.writeFileSync(modelPath, newContent);
-  console.log(chalk5.green(`  Injected into AppConfigModel`));
+  fs11.writeFileSync(modelPath, newContent);
+  console.log(chalk6.green(`  Injected into AppConfigModel`));
+  return modelPath;
 }
 function injectBeforeClassClose(content, className, line) {
   const classRegex = new RegExp(`class\\s+${className}\\s*[^{]*\\{`);
@@ -1893,9 +2037,9 @@ function injectIntoSuperCall(content, camelName) {
   return content.slice(0, parenEnd) + insertion + content.slice(parenEnd);
 }
 function findFileRecursive(dir, fileName) {
-  const entries = fs10.readdirSync(dir, { withFileTypes: true });
+  const entries = fs11.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path9.join(dir, entry.name);
+    const fullPath = path10.join(dir, entry.name);
     if (entry.isDirectory()) {
       const result = findFileRecursive(fullPath, fileName);
       if (result) return result;
@@ -1906,29 +2050,29 @@ function findFileRecursive(dir, fileName) {
   return null;
 }
 function discoverVendorsModules(monorepoRoot) {
-  const packagesDir = path9.join(monorepoRoot, "packages");
-  if (!fs10.existsSync(packagesDir)) return [];
+  const packagesDir = path10.join(monorepoRoot, "packages");
+  if (!fs11.existsSync(packagesDir)) return [];
   const results = [];
-  const packages = fs10.readdirSync(packagesDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+  const packages = fs11.readdirSync(packagesDir, { withFileTypes: true }).filter((d) => d.isDirectory());
   for (const pkg2 of packages) {
-    const pkgDir = path9.join(packagesDir, pkg2.name);
+    const pkgDir = path10.join(packagesDir, pkg2.name);
     const found = findFileRecursive(pkgDir, "vendors_module.dart");
     if (found) results.push(pkg2.name);
   }
   return results.sort();
 }
 function findAppConfigFile(monorepoRoot) {
-  const packagesDir = path9.join(monorepoRoot, "packages");
-  if (!fs10.existsSync(packagesDir)) return null;
+  const packagesDir = path10.join(monorepoRoot, "packages");
+  if (!fs11.existsSync(packagesDir)) return null;
   return findClassInPackages(packagesDir, "AppConfig");
 }
 function findAppConfigModelFile(monorepoRoot) {
-  const packagesDir = path9.join(monorepoRoot, "packages");
-  if (!fs10.existsSync(packagesDir)) return null;
+  const packagesDir = path10.join(monorepoRoot, "packages");
+  if (!fs11.existsSync(packagesDir)) return null;
   return findClassInPackages(packagesDir, "AppConfigModel");
 }
 function findClassInPackages(packagesDir, className) {
-  const packages = fs10.readdirSync(packagesDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => path9.join(packagesDir, d.name));
+  const packages = fs11.readdirSync(packagesDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => path10.join(packagesDir, d.name));
   for (const pkgDir of packages) {
     const found = findClassFileRecursive(pkgDir, className);
     if (found) return found;
@@ -1937,14 +2081,14 @@ function findClassInPackages(packagesDir, className) {
 }
 function findClassFileRecursive(dir, className) {
   const classRegex = new RegExp(`\\bclass\\s+${className}\\b`);
-  const entries = fs10.readdirSync(dir, { withFileTypes: true });
+  const entries = fs11.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path9.join(dir, entry.name);
+    const fullPath = path10.join(dir, entry.name);
     if (entry.isDirectory()) {
       const result = findClassFileRecursive(fullPath, className);
       if (result) return result;
     } else if (entry.name.endsWith(".dart") && !entry.name.endsWith(".g.dart")) {
-      const content = fs10.readFileSync(fullPath, "utf8");
+      const content = fs11.readFileSync(fullPath, "utf8");
       if (classRegex.test(content)) {
         return fullPath;
       }
@@ -1953,7 +2097,7 @@ function findClassFileRecursive(dir, className) {
   return null;
 }
 function findFileInPackages(packagesDir, fileName) {
-  const packages = fs10.readdirSync(packagesDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => path9.join(packagesDir, d.name));
+  const packages = fs11.readdirSync(packagesDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => path10.join(packagesDir, d.name));
   for (const pkgDir of packages) {
     const found = findFileRecursive(pkgDir, fileName);
     if (found) return found;
@@ -1961,9 +2105,9 @@ function findFileInPackages(packagesDir, fileName) {
   return null;
 }
 function formatPkgPath(monorepoRoot, absPath) {
-  return path9.relative(monorepoRoot, absPath);
+  return path10.relative(monorepoRoot, absPath);
 }
-var spinner = (msg) => console.log(chalk5.cyan(` \u2192 ${msg}`));
+var spinner = (msg) => console.log(chalk6.cyan(` \u2192 ${msg}`));
 async function createEnvVar(options) {
   const {
     monorepoRoot,
@@ -1975,37 +2119,42 @@ async function createEnvVar(options) {
     includeInAppConfig
   } = options;
   const camelName = screamingSnakeToCamel(variableName);
-  console.log(chalk5.bold(`
-Adding environment variable: ${chalk5.cyan(variableName)}
+  const modifiedFiles = [];
+  console.log(chalk6.bold(`
+Adding environment variable: ${chalk6.cyan(variableName)}
 `));
   spinner("PASO 1: Updating env JSON files");
   const jsonValue = typedJsonValue(defaultValue, dartType);
-  const appsDir = path9.join(monorepoRoot, "apps");
+  const appsDir = path10.join(monorepoRoot, "apps");
   for (const app of selectedApps) {
-    const appEnvDir = path9.join(appsDir, app, "env");
+    const appEnvDir = path10.join(appsDir, app, "env");
     const files = [
       { name: "example.env.json", isTemplate: true },
       { name: "development.env.json", isTemplate: false },
       { name: "production.env.json", isTemplate: false }
     ];
     for (const { name, isTemplate } of files) {
-      injectIntoJsonFile(path9.join(appEnvDir, name), variableName, jsonValue, isTemplate);
+      const modified = injectIntoJsonFile(path10.join(appEnvDir, name), variableName, jsonValue, isTemplate);
+      if (modified) modifiedFiles.push(modified);
     }
   }
   spinner("PASO 2: Injecting into AppEnvironment");
-  injectAbstractGetter(monorepoRoot, camelName, dartType);
+  const envFile = injectAbstractGetter(monorepoRoot, camelName, dartType);
+  if (envFile) modifiedFiles.push(envFile);
   spinner("PASO 3: Injecting into AppBuildEnvironment");
-  injectBuildEnvGetter(monorepoRoot, variableName, camelName, dartType);
+  const buildEnvFile = injectBuildEnvGetter(monorepoRoot, variableName, camelName, dartType);
+  if (buildEnvFile) modifiedFiles.push(buildEnvFile);
   if (includeInRemoteConfig) {
     spinner("PASO 4: Injecting into VendorsModule RemoteConfig");
     for (const pkgName of options.vendorsTargets) {
-      const pkgDir = path9.join(monorepoRoot, "packages", pkgName);
+      const pkgDir = path10.join(monorepoRoot, "packages", pkgName);
       const vendorsPath = findFileRecursive(pkgDir, "vendors_module.dart");
       if (vendorsPath) {
-        console.log(chalk5.cyan(`  \u2192 ${pkgName}/vendors_module.dart`));
-        injectIntoRemoteConfigDefaults(vendorsPath, camelName, dartType);
+        console.log(chalk6.cyan(`  \u2192 ${pkgName}/vendors_module.dart`));
+        const modified = injectIntoRemoteConfigDefaults(vendorsPath, camelName, dartType);
+        if (modified) modifiedFiles.push(modified);
       } else {
-        console.log(chalk5.yellow(`  vendors_module.dart not found in ${pkgName}`));
+        console.log(chalk6.yellow(`  vendors_module.dart not found in ${pkgName}`));
       }
     }
   }
@@ -2013,46 +2162,476 @@ Adding environment variable: ${chalk5.cyan(variableName)}
     spinner("PASO 5: Injecting into AppConfig entity");
     const configPath = findAppConfigFile(monorepoRoot);
     if (configPath) {
-      injectAppConfigProperty(configPath, camelName, dartType);
+      const modified = injectAppConfigProperty(configPath, camelName, dartType);
+      if (modified) modifiedFiles.push(modified);
     } else {
-      console.log(chalk5.yellow("  app_config.dart not found, skipping AppConfig"));
+      console.log(chalk6.yellow("  app_config.dart not found, skipping AppConfig"));
     }
     spinner("PASO 6: Injecting into AppConfigModel");
     const modelPath = findAppConfigModelFile(monorepoRoot);
     if (modelPath) {
-      injectAppConfigModelProperty(modelPath, camelName, dartType);
+      const modified = injectAppConfigModelProperty(modelPath, camelName, dartType);
+      if (modified) modifiedFiles.push(modified);
     } else {
-      console.log(chalk5.yellow("  app_config_model.dart not found, skipping AppConfigModel"));
+      console.log(chalk6.yellow("  app_config_model.dart not found, skipping AppConfigModel"));
+    }
+  }
+  console.log(chalk6.green("\nEnvironment variable added successfully!"));
+  const dartFiles = modifiedFiles.filter((f) => f.endsWith(".dart"));
+  if (dartFiles.length > 0) {
+    spinner("Running dart format on modified files...");
+    try {
+      const fileList = dartFiles.join(" ");
+      execSync(`dart format ${fileList}`, { cwd: monorepoRoot, stdio: "pipe" });
+      console.log(chalk6.green(`  Formatted ${dartFiles.length} file(s)`));
+    } catch {
+      console.log(chalk6.yellow("  dart format failed (you may need to run it manually)"));
     }
   }
-  console.log(chalk5.green("\nEnvironment variable added successfully!"));
-  spinner("Running melos format...");
+}
+
+// src/core/create-package.ts
+import * as fs12 from "fs";
+import * as path11 from "path";
+import { execSync as execSync2 } from "child_process";
+import chalk7 from "chalk";
+var MAIN_TESTER_CONTENT = `// ignore_for_file: avoid_print
+
+import 'dart:io';
+
+void main() {
+  final currentDir = Directory.current;
+  final testDir = Directory('\${currentDir.path}/test');
+
   try {
-    execSync("melos format", { cwd: monorepoRoot, stdio: "pipe" });
-    console.log(chalk5.green("  melos format completed"));
+    final entities = testDir.listSync(recursive: true);
+    final testFiles = <String>[];
+
+    print('Finding test files in \${testDir.path}:');
+    print('----------------------------------------');
+
+    for (final entity in entities) {
+      if (entity is File &&
+          entity.path.endsWith('_test.dart') &&
+          !entity.path.endsWith('/main_test.dart')) {
+        final fullPath = entity.path;
+        final relativePath = fullPath.substring(
+          testDir.path.length + 1,
+        );
+
+        print('Found test file: $relativePath');
+        testFiles.add(relativePath);
+      }
+    }
+
+    print('----------------------------------------');
+    print('Total test files found: \${testFiles.length}');
+
+    final mainTestContent = StringBuffer();
+
+    for (final file in testFiles) {
+      final importName = file.replaceAll('/', '_').replaceAll('.dart', '');
+      mainTestContent.writeln("import '$file' as $importName;");
+    }
+
+    mainTestContent.writeln('\\nvoid main() {');
+
+    for (final file in testFiles) {
+      final importName = file.replaceAll('/', '_').replaceAll('.dart', '');
+      mainTestContent.writeln('  $importName.main();');
+    }
+
+    mainTestContent.writeln('}');
+
+    final mainTestFile = File('\${testDir.path}/main_test.dart')
+      ..writeAsStringSync(mainTestContent.toString());
+
+    print('\\nCreated file: \${mainTestFile.path}');
+    print('----------------------------------------');
+  } on Exception catch (e) {
+    print('Error: $e');
+  }
+}
+`;
+function buildPubspecContent(packageName) {
+  const description = `${capitalize(packageName.replace(/_/g, " "))} package`;
+  return `name: ${packageName}
+description: "${description}"
+version: 0.0.1
+publish_to: none
+
+environment:
+  sdk: ^3.8.1
+  flutter: ">=1.17.0"
+
+dependencies:
+  core:
+  design_system:
+  flutter:
+    sdk: flutter
+  flutter_bloc: ^9.1.1
+  freezed_annotation: ^3.1.0
+  go_router: ^16.0.0
+  localization:
+
+dev_dependencies:
+  bloc_test: ^10.0.0
+  build_runner: ^2.5.4
+  flutter_test:
+    sdk: flutter
+  freezed: ^3.2.0
+  mocktail: ^1.0.4
+  very_good_analysis: ^9.0.0
+
+dependency_overrides:
+  source_gen: ^4.2.0
+
+flutter:
+  uses-material-design: true
+`;
+}
+function buildGitignoreContent() {
+  return `# Miscellaneous
+*.class
+*.log
+*.pyc
+*.swp
+.DS_Store
+.atom/
+.buildlog/
+.history
+.svn/
+migrate_working_dir/
+
+# IntelliJ related
+*.iml
+*.ipr
+*.iws
+.idea/
+
+# Flutter/Dart/Pub related
+/pubspec.lock
+**/doc/api/
+.dart_tool/
+.flutter-plugins
+.flutter-plugins-dependencies
+build/
+
+coverage/
+
+test/main_test.dart
+`;
+}
+function buildMakefileContent() {
+  return `.PHONY: test
+test:
+	dart test/main_tester.dart
+	dart format test/main_test.dart
+	dart fix --apply test/main_test.dart
+	flutter test --coverage test/main_test.dart
+`;
+}
+function buildAnalysisOptionsContent() {
+  return `include: ../../analysis_options.yaml
+`;
+}
+function buildBarrelExport(packageName) {
+  return `export 'bloc/bloc.dart';
+export 'pages/pages.dart';
+`;
+}
+function buildEmptyBarrel() {
+  return "";
+}
+function buildGitHubWorkflow(packageName) {
+  return `name: packages/${packageName}
+
+permissions:
+  contents: read
+  pull-requests: write
+
+concurrency:
+  group: \${{ github.workflow }}-\${{ github.event.pull_request.number || github.ref }}-${packageName}
+  cancel-in-progress: true
+
+on:
+  push:
+    branches:
+      - master
+    paths:
+      - "packages/${packageName}/**"
+      - ".github/workflows/${packageName}.yaml"
+      - ".github/workflows/test.yaml"
+  pull_request:
+    branches:
+      - master
+    paths:
+      - "packages/${packageName}/**"
+      - ".github/workflows/${packageName}.yaml"
+      - ".github/workflows/test.yaml"
+
+jobs:
+  test:
+    uses: ./.github/workflows/test.yaml
+    with:
+      package_name: ${packageName}
+      working_directory: packages/${packageName}
+`;
+}
+function capitalize(s) {
+  return s.replace(/\b\w/g, (c) => c.toUpperCase());
+}
+function findWorkspaceFile(monorepoRoot) {
+  const files = fs12.readdirSync(monorepoRoot);
+  return files.find((f) => f.endsWith(".code-workspace")) ?? null;
+}
+function updateCodeWorkspace(monorepoRoot, packageName) {
+  const wsFileName = findWorkspaceFile(monorepoRoot);
+  if (!wsFileName) {
+    console.log(chalk7.yellow("  No .code-workspace file found, skipping"));
+    return;
+  }
+  const wsPath = path11.join(monorepoRoot, wsFileName);
+  const content = fs12.readFileSync(wsPath, "utf8");
+  const folderPath = `packages/${packageName}`;
+  if (content.includes(`"path": "${folderPath}"`)) {
+    console.log(chalk7.yellow(`  Already in ${wsFileName}`));
+    return;
+  }
+  const folderName = `\u{1F4E6} ${packageName}`;
+  const newBlock = `    {
+      "name": "${folderName}",
+      "path": "${folderPath}"
+    },`;
+  const lines = content.split("\n");
+  const foldersLineIdx = lines.findIndex((l) => l.includes('"folders"'));
+  if (foldersLineIdx === -1) {
+    console.log(chalk7.yellow('  No "folders" key found in workspace, skipping'));
+    return;
+  }
+  let foldersOpenBracket = -1;
+  for (let j = foldersLineIdx; j < lines.length; j++) {
+    if (lines[j].includes("[")) {
+      foldersOpenBracket = j;
+      break;
+    }
+  }
+  if (foldersOpenBracket === -1) {
+    console.log(chalk7.yellow("  Could not find folders array, skipping"));
+    return;
+  }
+  let bracketCount = 0;
+  let foldersCloseBracket = -1;
+  for (let j = foldersOpenBracket; j < lines.length; j++) {
+    for (const ch of lines[j]) {
+      if (ch === "[") bracketCount++;
+      else if (ch === "]") {
+        bracketCount--;
+        if (bracketCount === 0) {
+          foldersCloseBracket = j;
+          break;
+        }
+      }
+    }
+    if (foldersCloseBracket !== -1) break;
+  }
+  if (foldersCloseBracket === -1) {
+    console.log(chalk7.yellow("  Could not find folders array end, skipping"));
+    return;
+  }
+  let widgetbookBlockStart = -1;
+  let idx = foldersOpenBracket + 1;
+  while (idx <= foldersCloseBracket) {
+    const trimmed = lines[idx].trim();
+    if (trimmed === "{" || trimmed.startsWith("{")) {
+      let braceCount = 0;
+      let blockEnd = -1;
+      for (let j = idx; j <= foldersCloseBracket; j++) {
+        for (const ch of lines[j]) {
+          if (ch === "{") braceCount++;
+          else if (ch === "}") {
+            braceCount--;
+            if (braceCount === 0) {
+              blockEnd = j;
+              break;
+            }
+          }
+        }
+        if (blockEnd !== -1) break;
+      }
+      if (blockEnd !== -1) {
+        const blockText = lines.slice(idx, blockEnd + 1).join("\n");
+        if (blockText.includes("widgetbook")) {
+          widgetbookBlockStart = idx;
+          break;
+        }
+        idx = blockEnd + 1;
+        continue;
+      }
+    }
+    idx++;
+  }
+  if (widgetbookBlockStart === -1) {
+    console.log(chalk7.yellow("  No widgetbook entry found in workspace, skipping"));
+    return;
+  }
+  lines.splice(widgetbookBlockStart, 0, newBlock);
+  fs12.writeFileSync(wsPath, lines.join("\n"));
+  console.log(chalk7.green(`  Updated ${wsFileName}`));
+}
+function updateHelixConfig(monorepoRoot, packageName) {
+  const helixPath = path11.join(monorepoRoot, ".helix", "languages.toml");
+  if (!fs12.existsSync(helixPath)) {
+    console.log(chalk7.yellow("  No .helix/languages.toml found, skipping"));
+    return;
+  }
+  let content = fs12.readFileSync(helixPath, "utf8");
+  const entry = `{ path = "packages/${packageName}" }`;
+  if (content.includes(entry)) {
+    console.log(chalk7.yellow("  Already in .helix/languages.toml"));
+    return;
+  }
+  const workspaceLineRegex = /^\s*\{\s*path\s*=\s*"packages\//;
+  const lines = content.split("\n");
+  let lastPackageLineIdx = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (workspaceLineRegex.test(lines[i])) {
+      lastPackageLineIdx = i;
+    }
+  }
+  if (lastPackageLineIdx === -1) {
+    const closingBracketIdx = lines.findIndex((l) => l.trim() === "]");
+    if (closingBracketIdx === -1) {
+      console.log(chalk7.yellow("  Could not parse .helix/languages.toml"));
+      return;
+    }
+    lines.splice(closingBracketIdx, 0, `  { path = "packages/${packageName}" },`);
+  } else {
+    const allPackageEntries = [];
+    for (let i = 0; i < lines.length; i++) {
+      const m = lines[i].match(/^\s*\{\s*path\s*=\s*"packages\/([^"]+)"\s*\}/);
+      if (m) {
+        allPackageEntries.push({ lineIdx: i, entry: m[1] });
+      }
+    }
+    allPackageEntries.push({ lineIdx: -1, entry: packageName });
+    allPackageEntries.sort((a, b) => a.entry.localeCompare(b.entry));
+    const insertIdx = allPackageEntries.findIndex((e) => e.entry === packageName);
+    let targetLine;
+    if (insertIdx === 0) {
+      const firstLine = lines.findIndex((l) => workspaceLineRegex.test(l));
+      targetLine = firstLine;
+    } else {
+      const prevEntry = allPackageEntries[insertIdx - 1];
+      targetLine = prevEntry.lineIdx + 1;
+    }
+    lines.splice(targetLine, 0, `  { path = "packages/${packageName}" },`);
+  }
+  fs12.writeFileSync(helixPath, lines.join("\n"));
+  console.log(chalk7.green("  Updated .helix/languages.toml"));
+}
+async function createPackage(options) {
+  const { monorepoRoot, packageName } = options;
+  const pkgDir = path11.join(monorepoRoot, "packages", packageName);
+  if (fs12.existsSync(pkgDir)) {
+    throw new Error(`packages/${packageName} already exists`);
+  }
+  console.log(chalk7.bold(`
+Creating package: ${chalk7.cyan(packageName)}
+`));
+  console.log(chalk7.cyan(" \u2192 Running flutter create..."));
+  execSync2(`flutter create -t package packages/${packageName}`, {
+    cwd: monorepoRoot,
+    stdio: "pipe"
+  });
+  const autoTestFile = path11.join(pkgDir, "test", `${packageName}_test.dart`);
+  if (fs12.existsSync(autoTestFile)) {
+    fs12.unlinkSync(autoTestFile);
+  }
+  console.log(chalk7.cyan(" \u2192 Customizing package files..."));
+  fs12.writeFileSync(
+    path11.join(pkgDir, "pubspec.yaml"),
+    buildPubspecContent(packageName)
+  );
+  fs12.writeFileSync(
+    path11.join(pkgDir, ".gitignore"),
+    buildGitignoreContent()
+  );
+  fs12.writeFileSync(
+    path11.join(pkgDir, "analysis_options.yaml"),
+    buildAnalysisOptionsContent()
+  );
+  fs12.writeFileSync(
+    path11.join(pkgDir, "Makefile"),
+    buildMakefileContent()
+  );
+  const libDir = path11.join(pkgDir, "lib");
+  fs12.writeFileSync(
+    path11.join(libDir, `${packageName}.dart`),
+    buildBarrelExport(packageName)
+  );
+  fs12.mkdirSync(path11.join(libDir, "bloc"), { recursive: true });
+  fs12.writeFileSync(
+    path11.join(libDir, "bloc", "bloc.dart"),
+    buildEmptyBarrel()
+  );
+  fs12.mkdirSync(path11.join(libDir, "pages"), { recursive: true });
+  fs12.writeFileSync(
+    path11.join(libDir, "pages", "pages.dart"),
+    buildEmptyBarrel()
+  );
+  const testDir = path11.join(pkgDir, "test");
+  if (!fs12.existsSync(testDir)) {
+    fs12.mkdirSync(testDir, { recursive: true });
+  }
+  fs12.writeFileSync(
+    path11.join(testDir, "main_tester.dart"),
+    MAIN_TESTER_CONTENT
+  );
+  console.log(chalk7.cyan(" \u2192 Updating workspace configuration..."));
+  updateCodeWorkspace(monorepoRoot, packageName);
+  updateHelixConfig(monorepoRoot, packageName);
+  console.log(chalk7.cyan(" \u2192 Creating GitHub Actions workflow..."));
+  const workflowsDir = path11.join(monorepoRoot, ".github", "workflows");
+  if (fs12.existsSync(workflowsDir)) {
+    fs12.writeFileSync(
+      path11.join(workflowsDir, `${packageName}.yaml`),
+      buildGitHubWorkflow(packageName)
+    );
+    console.log(chalk7.green(`  Created .github/workflows/${packageName}.yaml`));
+  } else {
+    console.log(chalk7.yellow("  No .github/workflows/ directory found, skipping CI workflow"));
+  }
+  console.log(chalk7.cyan(" \u2192 Running melos bootstrap..."));
+  try {
+    execSync2("melos bootstrap", { cwd: monorepoRoot, stdio: "pipe" });
+    console.log(chalk7.green("  melos bootstrap completed"));
   } catch {
-    console.log(chalk5.yellow("  melos format failed (you may need to run it manually)"));
+    console.log(chalk7.yellow("  melos bootstrap failed (you may need to run it manually)"));
   }
+  console.log(chalk7.green(`
+Package "${packageName}" created successfully!`));
+  console.log(chalk7.gray(`  ${pkgDir}`));
 }
 
 // src/core/docs-serve.ts
 import { spawn as spawn2 } from "child_process";
-import * as fs11 from "fs";
-import * as path10 from "path";
-import chalk6 from "chalk";
+import * as fs13 from "fs";
+import * as path12 from "path";
+import chalk8 from "chalk";
 function detectBookDir(startDir) {
   const root = findMonorepoRoot(startDir) ?? startDir;
-  const bookDir = path10.join(root, "book");
-  if (fs11.existsSync(bookDir) && (fs11.existsSync(path10.join(bookDir, "docusaurus.config.js")) || fs11.existsSync(path10.join(bookDir, "docusaurus.config.ts")) || fs11.existsSync(path10.join(bookDir, "docusaurus.config.mjs")))) {
+  const bookDir = path12.join(root, "book");
+  if (fs13.existsSync(bookDir) && (fs13.existsSync(path12.join(bookDir, "docusaurus.config")) || fs13.existsSync(path12.join(bookDir, "docusaurus.config.ts")) || fs13.existsSync(path12.join(bookDir, "docusaurus.config.mjs")))) {
     return bookDir;
   }
   return void 0;
 }
 function serveBook(bookDir) {
-  return new Promise((resolve4, reject) => {
-    const nodeModules = path10.join(bookDir, "node_modules");
-    if (!fs11.existsSync(nodeModules)) {
-      console.log(chalk6.cyan("Installing book dependencies..."));
+  return new Promise((resolve5, reject) => {
+    const nodeModules = path12.join(bookDir, "node_modules");
+    if (!fs13.existsSync(nodeModules)) {
+      console.log(chalk8.cyan("Installing book dependencies..."));
       const install = spawn2("npm", ["install"], {
         cwd: bookDir,
         stdio: "inherit"
@@ -2062,13 +2641,13 @@ function serveBook(bookDir) {
           reject(new Error(`npm install failed with code ${code}`));
           return;
         }
-        startDevServer(bookDir, resolve4);
+        startDevServer(bookDir, resolve5);
       });
       install.on("error", (err) => {
         reject(err);
       });
     } else {
-      startDevServer(bookDir, resolve4);
+      startDevServer(bookDir, resolve5);
     }
   });
 }
@@ -2086,16 +2665,16 @@ function startDevServer(bookDir, done) {
 }
 
 // src/core/docs-commands.ts
-import * as fs12 from "fs";
-import * as path11 from "path";
-import chalk7 from "chalk";
+import * as fs14 from "fs";
+import * as path13 from "path";
+import chalk9 from "chalk";
 import YAML2 from "yaml";
 function parseMakefile(filePath) {
-  if (!fs12.existsSync(filePath)) return [];
-  const content = fs12.readFileSync(filePath, "utf8");
+  if (!fs14.existsSync(filePath)) return [];
+  const content = fs14.readFileSync(filePath, "utf8");
   const lines = content.split("\n");
   const commands = [];
-  const source = path11.basename(filePath);
+  const source = path13.basename(filePath);
   let pendingComments = [];
   for (let i = 0; i < lines.length; i++) {
     const line = lines[i];
@@ -2125,13 +2704,13 @@ function parseMakefile(filePath) {
   return commands;
 }
 function parseMelosScripts(filePath) {
-  if (!fs12.existsSync(filePath)) return [];
-  const content = fs12.readFileSync(filePath, "utf8");
+  if (!fs14.existsSync(filePath)) return [];
+  const content = fs14.readFileSync(filePath, "utf8");
   const parsed = YAML2.parse(content);
   const scripts = parsed?.scripts;
   if (!scripts || typeof scripts !== "object") return [];
   const commands = [];
-  const source = path11.basename(filePath);
+  const source = path13.basename(filePath);
   for (const [name, value] of Object.entries(scripts)) {
     let description = "";
     let command = "";
@@ -2153,17 +2732,17 @@ function parseMelosScripts(filePath) {
 function discoverCommands(startDir) {
   const root = findMonorepoRoot(startDir) ?? startDir;
   const commands = [];
-  const rootMakefile = path11.join(root, "Makefile");
+  const rootMakefile = path13.join(root, "Makefile");
   commands.push(...parseMakefile(rootMakefile));
-  const melosFile = path11.join(root, "melos.yaml");
+  const melosFile = path13.join(root, "melos.yaml");
   commands.push(...parseMelosScripts(melosFile));
-  const bookMakefile = path11.join(root, "book", "Makefile");
+  const bookMakefile = path13.join(root, "book", "Makefile");
   commands.push(...parseMakefile(bookMakefile));
   return commands;
 }
 function displayCommands(commands) {
   if (commands.length === 0) {
-    console.log(chalk7.yellow("No commands found."));
+    console.log(chalk9.yellow("No commands found."));
     return;
   }
   const groups = /* @__PURE__ */ new Map();
@@ -2173,13 +2752,13 @@ function displayCommands(commands) {
     groups.get(key).push(cmd);
   }
   for (const [group, entries] of groups) {
-    console.log(chalk7.bold(chalk7.cyan(`
+    console.log(chalk9.bold(chalk9.cyan(`
 ${group}`)));
-    console.log(chalk7.cyan("\u2500".repeat(group.length)));
+    console.log(chalk9.cyan("\u2500".repeat(group.length)));
     const maxNameLen = Math.max(...entries.map((e) => e.name.length));
     for (const entry of entries) {
-      const name = chalk7.white(entry.name.padEnd(maxNameLen + 2));
-      const desc = entry.description ? chalk7.gray(entry.description) : chalk7.dim("(no description)");
+      const name = chalk9.white(entry.name.padEnd(maxNameLen + 2));
+      const desc = entry.description ? chalk9.gray(entry.description) : chalk9.dim("(no description)");
       console.log(`  ${name} ${desc}`);
     }
   }
@@ -2187,9 +2766,9 @@ ${group}`)));
 }
 
 // src/core/docs-architecture.ts
-import * as fs13 from "fs";
-import * as path12 from "path";
-import chalk8 from "chalk";
+import * as fs15 from "fs";
+import * as path14 from "path";
+import chalk10 from "chalk";
 import YAML3 from "yaml";
 var KEY_DEPS = [
   "freezed",
@@ -2207,18 +2786,18 @@ var KEY_DEPS = [
 function discoverArchitecture(startDir) {
   const root = findMonorepoRoot(startDir);
   if (!root) return null;
-  const melosPath = path12.join(root, "melos.yaml");
-  if (!fs13.existsSync(melosPath)) return null;
-  const melosContent = fs13.readFileSync(melosPath, "utf8");
+  const melosPath = path14.join(root, "melos.yaml");
+  if (!fs15.existsSync(melosPath)) return null;
+  const melosContent = fs15.readFileSync(melosPath, "utf8");
   const melos = YAML3.parse(melosContent);
-  const projectName = melos?.name ?? path12.basename(root);
+  const projectName = melos?.name ?? path14.basename(root);
   const apps = [];
-  const appsDir = path12.join(root, "apps");
-  if (fs13.existsSync(appsDir)) {
-    for (const entry of fs13.readdirSync(appsDir, { withFileTypes: true })) {
+  const appsDir = path14.join(root, "apps");
+  if (fs15.existsSync(appsDir)) {
+    for (const entry of fs15.readdirSync(appsDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      const candidate = path12.join(appsDir, entry.name);
-      if (fs13.existsSync(path12.join(candidate, "pubspec.yaml"))) {
+      const candidate = path14.join(appsDir, entry.name);
+      if (fs15.existsSync(path14.join(candidate, "pubspec.yaml"))) {
         apps.push({ name: entry.name, dir: candidate });
       }
     }
@@ -2226,14 +2805,14 @@ function discoverArchitecture(startDir) {
   const packages = [];
   const packageBases = ["packages", "packages/features"];
   for (const base of packageBases) {
-    const baseDir = path12.join(root, base);
-    if (!fs13.existsSync(baseDir)) continue;
-    for (const entry of fs13.readdirSync(baseDir, { withFileTypes: true })) {
+    const baseDir = path14.join(root, base);
+    if (!fs15.existsSync(baseDir)) continue;
+    for (const entry of fs15.readdirSync(baseDir, { withFileTypes: true })) {
       if (!entry.isDirectory()) continue;
-      const candidate = path12.join(baseDir, entry.name);
-      const pubspecPath = path12.join(candidate, "pubspec.yaml");
-      if (!fs13.existsSync(pubspecPath)) continue;
-      const content = fs13.readFileSync(pubspecPath, "utf8");
+      const candidate = path14.join(baseDir, entry.name);
+      const pubspecPath = path14.join(candidate, "pubspec.yaml");
+      if (!fs15.existsSync(pubspecPath)) continue;
+      const content = fs15.readFileSync(pubspecPath, "utf8");
       const pubspec = YAML3.parse(content);
       const deps = {
         ...pubspec?.dependencies,
@@ -2268,30 +2847,30 @@ function displayArchitecture(info) {
   const L = "\u2514\u2500\u2500 ";
   const I = "\u2502   ";
   const S = "    ";
-  console.log(chalk8.bold(chalk8.cyan(info.projectName)) + chalk8.gray(`  (${info.root})`));
+  console.log(chalk10.bold(chalk10.cyan(info.projectName)) + chalk10.gray(`  (${info.root})`));
   console.log(`${I}`);
   if (info.apps.length > 0) {
-    console.log(chalk8.white(`${T}apps/`));
+    console.log(chalk10.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}${chalk8.green(app.name)}`);
+      console.log(`${prefix}${chalk10.green(app.name)}`);
     }
   }
   if (info.packages.length > 0) {
     const rootPkgs = info.packages.filter(
-      (p) => !p.dir.includes(`${path12.sep}features${path12.sep}`)
+      (p) => !p.dir.includes(`${path14.sep}features${path14.sep}`)
     );
     const featurePkgs = info.packages.filter(
-      (p) => p.dir.includes(`${path12.sep}features${path12.sep}`)
+      (p) => p.dir.includes(`${path14.sep}features${path14.sep}`)
     );
-    console.log(chalk8.white(`${T}packages/`));
+    console.log(chalk10.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 ? chalk8.dim(` [${pkg2.keyDeps.join(", ")}]`) : "";
-      console.log(`${prefix}${chalk8.yellow(pkg2.name)}${deps}`);
+      const deps = pkg2.keyDeps.length > 0 ? chalk10.dim(` [${pkg2.keyDeps.join(", ")}]`) : "";
+      console.log(`${prefix}${chalk10.yellow(pkg2.name)}${deps}`);
     }
     if (featurePkgs.length > 0) {
       console.log(`${I}${S}${T}features/`);
@@ -2299,33 +2878,33 @@ function displayArchitecture(info) {
         const pkg2 = featurePkgs[i];
         const isLast = i === featurePkgs.length - 1;
         const prefix = isLast ? `${I}${S}${S}${L}` : `${I}${S}${S}${T}`;
-        const deps = pkg2.keyDeps.length > 0 ? chalk8.dim(` [${pkg2.keyDeps.join(", ")}]`) : "";
-        console.log(`${prefix}${chalk8.yellow(pkg2.name)}${deps}`);
+        const deps = pkg2.keyDeps.length > 0 ? chalk10.dim(` [${pkg2.keyDeps.join(", ")}]`) : "";
+        console.log(`${prefix}${chalk10.yellow(pkg2.name)}${deps}`);
       }
     }
   }
   if (info.hasDesignSystem) {
-    const tiers = info.designSystemTiers.length > 0 ? chalk8.dim(` (${info.designSystemTiers.join(", ")})`) : "";
-    console.log(`${T}${chalk8.magenta("design_system")}${tiers}`);
+    const tiers = info.designSystemTiers.length > 0 ? chalk10.dim(` (${info.designSystemTiers.join(", ")})`) : "";
+    console.log(`${T}${chalk10.magenta("design_system")}${tiers}`);
   }
-  const bookDir = path12.join(info.root, "book");
-  if (fs13.existsSync(bookDir)) {
-    console.log(`${T}${chalk8.blue("book/")}` + chalk8.dim(" (Docusaurus)"));
+  const bookDir = path14.join(info.root, "book");
+  if (fs15.existsSync(bookDir)) {
+    console.log(`${T}${chalk10.blue("book/")}` + chalk10.dim(" (Docusaurus)"));
   }
-  if (fs13.existsSync(path12.join(info.root, "melos.yaml"))) {
-    console.log(`${L}${chalk8.gray("melos.yaml")}`);
+  if (fs15.existsSync(path14.join(info.root, "melos.yaml"))) {
+    console.log(`${L}${chalk10.gray("melos.yaml")}`);
   }
   console.log();
 }
 
 // src/interactive.ts
-var SNAKE_CASE_REGEX4 = /^[a-z][a-z0-9_]*$/;
+var SNAKE_CASE_REGEX5 = /^[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 ${chalk9.green(cwdProject.projectName)}`);
+    s.stop(`Found ${chalk11.green(cwdProject.projectName)}`);
     return cwdProject;
   }
   s.message("Looking for Melos monorepo...");
@@ -2338,8 +2917,8 @@ async function resolveProject() {
     }
   }
   s.message("Scanning for Flutter projects...");
-  const homeDev = path13.join(os.homedir(), "Development");
-  if (fs14.existsSync(homeDev)) {
+  const homeDev = path15.join(os.homedir(), "Development");
+  if (fs16.existsSync(homeDev)) {
     const projects = discoverProjects(homeDev, 2);
     if (projects.length > 0) {
       s.stop(`Found ${projects.length} Flutter project(s)`);
@@ -2347,12 +2926,12 @@ async function resolveProject() {
     }
   }
   s.stop("No Flutter projects found");
-  clack.outro(chalk9.red("Could not find any Flutter project with freezed or flutter_bloc."));
+  clack.outro(chalk11.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 ${chalk9.green(projects[0].projectName)}`);
+    clack.log.info(`Using ${chalk11.green(projects[0].projectName)}`);
     return projects[0];
   }
   const selected = await clack.select({
@@ -2360,7 +2939,7 @@ async function selectPackage(projects) {
     options: projects.map((p) => ({
       value: p,
       label: p.projectName,
-      hint: path13.relative(os.homedir(), p.projectRoot)
+      hint: path15.relative(os.homedir(), p.projectRoot)
     }))
   });
   if (clack.isCancel(selected)) {
@@ -2375,7 +2954,7 @@ async function blocFlow(project) {
     placeholder: "e.g. user_login",
     validate: (value) => {
       if (!value.trim()) return "Name is required";
-      if (!SNAKE_CASE_REGEX4.test(value))
+      if (!SNAKE_CASE_REGEX5.test(value))
         return "Must be snake_case (lowercase, digits, underscores)";
     }
   });
@@ -2408,13 +2987,13 @@ async function blocFlow(project) {
         clack.cancel("Cancelled");
         return;
       }
-      targetDir = path13.resolve(customPath);
+      targetDir = path15.resolve(customPath);
     } else {
-      targetDir = path13.join(project.projectRoot, "lib", "features", feature);
+      targetDir = path15.join(project.projectRoot, "lib", "features", feature);
     }
-  } else if (fs14.existsSync(path13.join(project.projectRoot, "lib", "bloc"))) {
-    targetDir = path13.join(project.projectRoot, "lib", "bloc");
-    clack.log.info(`Target: ${chalk9.cyan("lib/bloc/")}`);
+  } else if (fs16.existsSync(path15.join(project.projectRoot, "lib", "bloc"))) {
+    targetDir = path15.join(project.projectRoot, "lib", "bloc");
+    clack.log.info(`Target: ${chalk11.cyan("lib/bloc/")}`);
   } else {
     clack.note(
       "No lib/features/ directory found. Provide a target path manually.",
@@ -2431,7 +3010,7 @@ async function blocFlow(project) {
       clack.cancel("Cancelled");
       return;
     }
-    targetDir = path13.resolve(customPath);
+    targetDir = path15.resolve(customPath);
   }
   const defaultRun = project.hasBuildRunner;
   const runBuildRunner2 = await clack.confirm({
@@ -2450,10 +3029,10 @@ async function blocFlow(project) {
       buildRunner: runBuildRunner2
     });
     genSpinner.stop("BLoC generated");
-    clack.outro(chalk9.green("Done!"));
+    clack.outro(chalk11.green("Done!"));
   } catch (error) {
     genSpinner.stop("Failed");
-    clack.outro(chalk9.red(`Error: ${error}`));
+    clack.outro(chalk11.red(`Error: ${error}`));
   }
 }
 async function widgetFlow() {
@@ -2461,14 +3040,14 @@ async function widgetFlow() {
   const ds = detectDesignSystem(projectRoot);
   if (!ds) {
     clack.outro(
-      chalk9.red(
+      chalk11.red(
         "No design system detected. Run this command from a project with wl_design_system/ directory."
       )
     );
     return;
   }
   clack.log.info(
-    `Design system: ${chalk9.cyan(path13.relative(projectRoot, ds.componentsDir))}`
+    `Design system: ${chalk11.cyan(path15.relative(projectRoot, ds.componentsDir))}`
   );
   const name = await clack.text({
     message: "Widget name (snake_case, without wl_ prefix)",
@@ -2476,7 +3055,7 @@ async function widgetFlow() {
     validate: (value) => {
       if (!value.trim()) return "Name is required";
       const clean = value.startsWith("wl_") ? value.slice(3) : value;
-      if (!SNAKE_CASE_REGEX4.test(clean))
+      if (!SNAKE_CASE_REGEX5.test(clean))
         return "Must be snake_case (lowercase, digits, underscores)";
     }
   });
@@ -2533,17 +3112,17 @@ async function widgetFlow() {
         genSpinner.stop(`Use-case skipped: ${e}`);
       }
     }
-    clack.outro(chalk9.green("Done!"));
+    clack.outro(chalk11.green("Done!"));
   } catch (error) {
     genSpinner.stop("Failed");
-    clack.outro(chalk9.red(`Error: ${error}`));
+    clack.outro(chalk11.red(`Error: ${error}`));
   }
 }
 async function useCaseFlow() {
   const ds = detectDesignSystem(process.cwd());
   if (!ds) {
     clack.outro(
-      chalk9.red(
+      chalk11.red(
         "No design system detected. Ensure wl_design_system/ directory exists."
       )
     );
@@ -2551,7 +3130,7 @@ async function useCaseFlow() {
   }
   if (!ds.widgetbookDir) {
     clack.outro(
-      chalk9.red(
+      chalk11.red(
         "No widgetbook package detected. Ensure apps/widgetbook/ exists."
       )
     );
@@ -2563,7 +3142,7 @@ async function useCaseFlow() {
     validate: (value) => {
       if (!value.trim()) return "Name is required";
       const clean = value.startsWith("wl_") ? value.slice(3) : value;
-      if (!SNAKE_CASE_REGEX4.test(clean))
+      if (!SNAKE_CASE_REGEX5.test(clean))
         return "Must be snake_case (lowercase, digits, underscores)";
     }
   });
@@ -2600,18 +3179,123 @@ async function useCaseFlow() {
       buildRunner: runBuildRunner2
     });
     genSpinner.stop("Use-case generated");
-    clack.outro(chalk9.green("Done!"));
+    clack.outro(chalk11.green("Done!"));
   } catch (error) {
     genSpinner.stop("Failed");
-    clack.outro(chalk9.red(`Error: ${error}`));
+    clack.outro(chalk11.red(`Error: ${error}`));
+  }
+}
+function discoverMonorepoPackages(monorepoRoot) {
+  const results = [];
+  const packageBases = ["packages", "packages/features"];
+  for (const base of packageBases) {
+    const baseDir = path15.join(monorepoRoot, base);
+    if (!fs16.existsSync(baseDir)) continue;
+    const entries = fs16.readdirSync(baseDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const pkgDir = path15.join(baseDir, entry.name);
+      if (fs16.existsSync(path15.join(pkgDir, "pubspec.yaml"))) {
+        results.push({ name: entry.name, pagesDir: path15.join(pkgDir, "lib", "pages") });
+      }
+    }
   }
+  return results.sort((a, b) => a.name.localeCompare(b.name));
+}
+async function pageFlow(initialName, initialPath) {
+  const name = initialName ?? await clack.text({
+    message: "Page name (snake_case)",
+    placeholder: "e.g. profile, order_detail",
+    validate: (value) => {
+      if (!value.trim()) return "Name is required";
+      if (!SNAKE_CASE_REGEX5.test(value))
+        return "Must be snake_case (lowercase, digits, underscores)";
+    }
+  });
+  if (clack.isCancel(name)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  let pagesPath = initialPath;
+  if (!pagesPath) {
+    const monorepoRoot = findMonorepoRoot(process.cwd());
+    if (monorepoRoot) {
+      const packages = discoverMonorepoPackages(monorepoRoot);
+      if (packages.length > 0) {
+        const selected = await clack.select({
+          message: "Select package where the page will be created",
+          options: [
+            ...packages.map((p) => ({
+              value: p.pagesDir,
+              label: p.name,
+              hint: path15.relative(monorepoRoot, p.pagesDir)
+            })),
+            { value: "__custom__", label: "Custom path..." }
+          ]
+        });
+        if (clack.isCancel(selected)) {
+          clack.cancel("Cancelled");
+          return;
+        }
+        if (selected === "__custom__") {
+          const customPath = await clack.text({
+            message: "Absolute path to pages directory",
+            placeholder: "/path/to/packages/home/lib/pages",
+            validate: (v) => {
+              if (!v.trim()) return "Path is required";
+              const resolved = path15.resolve(v.trim());
+              if (!fs16.existsSync(resolved)) return "Path does not exist";
+            }
+          });
+          if (clack.isCancel(customPath)) {
+            clack.cancel("Cancelled");
+            return;
+          }
+          pagesPath = path15.resolve(customPath);
+        } else {
+          pagesPath = selected;
+        }
+      } else {
+        pagesPath = await askManualPagesPath();
+      }
+    } else {
+      pagesPath = await askManualPagesPath();
+    }
+  }
+  if (!pagesPath) return;
+  const genSpinner = clack.spinner();
+  genSpinner.start("Creating page...");
+  try {
+    await createPage(name, { pagesPath });
+    genSpinner.stop("Page created");
+    clack.outro(chalk11.green("Done!"));
+  } catch (error) {
+    genSpinner.stop("Failed");
+    clack.outro(chalk11.red(`Error: ${error}`));
+  }
+}
+async function askManualPagesPath() {
+  const customPath = await clack.text({
+    message: "Absolute path to pages directory",
+    placeholder: "/path/to/project/lib/pages",
+    validate: (v) => {
+      if (!v.trim()) return "Path is required";
+      const resolved = path15.resolve(v.trim());
+      if (!fs16.existsSync(resolved)) return "Path does not exist";
+    }
+  });
+  if (clack.isCancel(customPath)) {
+    clack.cancel("Cancelled");
+    return void 0;
+  }
+  return path15.resolve(customPath);
 }
 function findBffFiles(dir) {
   const results = [];
-  if (!fs14.existsSync(dir)) return results;
-  const entries = fs14.readdirSync(dir, { withFileTypes: true });
+  if (!fs16.existsSync(dir)) return results;
+  const entries = fs16.readdirSync(dir, { withFileTypes: true });
   for (const entry of entries) {
-    const fullPath = path13.join(dir, entry.name);
+    const fullPath = path15.join(dir, entry.name);
     if (entry.isDirectory()) {
       results.push(...findBffFiles(fullPath));
     } else if (entry.isFile() && entry.name.endsWith(".dart") && !entry.name.includes(".g.")) {
@@ -2623,8 +3307,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(path13.basename(f))).map((f) => {
-    const base = path13.basename(f, ".dart");
+  const withDomains = bffFiles.filter((f) => /^bff_.+_api\.dart$/.test(path15.basename(f))).map((f) => {
+    const base = path15.basename(f, ".dart");
     const domain = base.replace(/^bff_/, "").replace(/_api$/, "");
     return { file: f, domain };
   });
@@ -2651,19 +3335,19 @@ async function resolveEndpointProject() {
     s.message(`Monorepo found at ${monorepoRoot}`);
     const packageBases = ["packages", "packages/features"];
     for (const base of packageBases) {
-      const baseDir = path13.join(monorepoRoot, base);
-      if (!fs14.existsSync(baseDir)) continue;
-      const entries = fs14.readdirSync(baseDir, { withFileTypes: true });
+      const baseDir = path15.join(monorepoRoot, base);
+      if (!fs16.existsSync(baseDir)) continue;
+      const entries = fs16.readdirSync(baseDir, { withFileTypes: true });
       for (const entry of entries) {
         if (!entry.isDirectory()) continue;
-        const candidate = path13.join(baseDir, entry.name);
-        if (!fs14.existsSync(path13.join(candidate, "pubspec.yaml"))) continue;
-        const bffPath = path13.join(candidate, "lib", "data", "api", "bff");
-        s.message(`Checking ${candidate} \u2192 bff exists: ${fs14.existsSync(bffPath)}`);
-        if (fs14.existsSync(bffPath)) {
+        const candidate = path15.join(baseDir, entry.name);
+        if (!fs16.existsSync(path15.join(candidate, "pubspec.yaml"))) continue;
+        const bffPath = path15.join(candidate, "lib", "data", "api", "bff");
+        s.message(`Checking ${candidate} \u2192 bff exists: ${fs16.existsSync(bffPath)}`);
+        if (fs16.existsSync(bffPath)) {
           const project2 = analyzeProject(candidate);
           if (project2) {
-            s.stop(`Using ${chalk9.green(project2.projectName)}`);
+            s.stop(`Using ${chalk11.green(project2.projectName)}`);
             return project2;
           }
         }
@@ -2673,8 +3357,8 @@ async function resolveEndpointProject() {
     s.message("No monorepo root found");
   }
   const cwdProject = analyzeProject(process.cwd());
-  if (cwdProject && fs14.existsSync(path13.join(cwdProject.projectRoot, "lib", "data", "api", "bff"))) {
-    s.stop(`Using ${chalk9.green(cwdProject.projectName)}`);
+  if (cwdProject && fs16.existsSync(path15.join(cwdProject.projectRoot, "lib", "data", "api", "bff"))) {
+    s.stop(`Using ${chalk11.green(cwdProject.projectName)}`);
     return cwdProject;
   }
   s.stop("No BFF package found");
@@ -2683,33 +3367,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 = path13.resolve(v.trim());
-      if (!fs14.existsSync(resolved2)) return "Path does not exist";
-      if (!fs14.existsSync(path13.join(resolved2, "pubspec.yaml"))) return "No pubspec.yaml found at this path";
-      if (!fs14.existsSync(path13.join(resolved2, "lib", "data", "api", "bff"))) return "No lib/data/api/bff/ found at this path";
+      const resolved2 = path15.resolve(v.trim());
+      if (!fs16.existsSync(resolved2)) return "Path does not exist";
+      if (!fs16.existsSync(path15.join(resolved2, "pubspec.yaml"))) return "No pubspec.yaml found at this path";
+      if (!fs16.existsSync(path15.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 = path13.resolve(manualPath);
+  const resolved = path15.resolve(manualPath);
   const project = analyzeProject(resolved);
   if (!project) {
-    clack.outro(chalk9.red(`Could not analyze project at ${resolved}`));
+    clack.outro(chalk11.red(`Could not analyze project at ${resolved}`));
     return null;
   }
-  clack.log.info(`Using ${chalk9.green(project.projectName)}`);
+  clack.log.info(`Using ${chalk11.green(project.projectName)}`);
   return project;
 }
 async function endpointFlow() {
   const project = await resolveEndpointProject();
   if (!project) return;
-  const lib = path13.join(project.projectRoot, "lib");
-  const bffDir = path13.join(lib, "data", "api", "bff");
+  const lib = path15.join(project.projectRoot, "lib");
+  const bffDir = path15.join(lib, "data", "api", "bff");
   const bffFiles = findBffFiles(bffDir);
   if (bffFiles.length === 0) {
-    clack.outro(chalk9.red("No BFF API files found. Ensure lib/data/api/bff/ exists with .dart files."));
+    clack.outro(chalk11.red("No BFF API files found. Ensure lib/data/api/bff/ exists with .dart files."));
     return;
   }
   const httpMethod = await clack.select({
@@ -2739,13 +3423,13 @@ async function endpointFlow() {
   }
   let bffApiFile = inferBffFile(bffFiles, endpointPath);
   if (bffApiFile) {
-    clack.log.info(`Auto-detected BFF file: ${chalk9.cyan(path13.basename(bffApiFile))}`);
+    clack.log.info(`Auto-detected BFF file: ${chalk11.cyan(path15.basename(bffApiFile))}`);
   } else {
     const selected = await clack.select({
       message: "Could not auto-detect BFF file. Select one:",
       options: bffFiles.map((f) => ({
         value: f,
-        label: path13.relative(bffDir, f)
+        label: path15.relative(bffDir, f)
       }))
     });
     if (clack.isCancel(selected)) {
@@ -2763,7 +3447,7 @@ async function endpointFlow() {
     initialValue: inferredName,
     validate: (v) => {
       if (!v.trim()) return "Name is required";
-      if (!SNAKE_CASE_REGEX4.test(v)) return "Must be snake_case";
+      if (!SNAKE_CASE_REGEX5.test(v)) return "Must be snake_case";
     }
   });
   if (clack.isCancel(useCaseName)) {
@@ -2809,14 +3493,49 @@ async function endpointFlow() {
       diLazySingleton
     });
     genSpinner.stop("Endpoint generated");
-    clack.outro(chalk9.green("Done!"));
+    clack.outro(chalk11.green("Done!"));
+  } catch (error) {
+    genSpinner.stop("Failed");
+    clack.outro(chalk11.red(`Error: ${error}`));
+  }
+}
+async function packageFlow() {
+  const monorepoRoot = findMonorepoRoot(process.cwd());
+  if (!monorepoRoot) {
+    clack.outro(chalk11.red("Not inside a monorepo. Run from within a Melos monorepo."));
+    return;
+  }
+  clack.log.info(`Monorepo: ${chalk11.cyan(path15.relative(os.homedir(), monorepoRoot))}`);
+  const name = await clack.text({
+    message: "Package name (snake_case)",
+    placeholder: "e.g. rewards, promotions, notifications",
+    validate: (value) => {
+      if (!value || !value.trim()) return "Name is required";
+      if (!SNAKE_CASE_REGEX5.test(value)) return "Must be snake_case (lowercase, digits, underscores)";
+      const pkgDir = path15.join(monorepoRoot, "packages", value);
+      if (fs16.existsSync(pkgDir)) return `packages/${value} already exists`;
+    }
+  });
+  if (clack.isCancel(name)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  const genSpinner = clack.spinner();
+  genSpinner.start("Creating package...");
+  try {
+    await createPackage({
+      monorepoRoot,
+      packageName: name
+    });
+    genSpinner.stop("Package created");
+    clack.outro(chalk11.green("Done!"));
   } catch (error) {
     genSpinner.stop("Failed");
-    clack.outro(chalk9.red(`Error: ${error}`));
+    clack.outro(chalk11.red(`Error: ${error}`));
   }
 }
 async function docsInteractiveMode() {
-  clack.intro(chalk9.bgCyan(chalk9.black(" wlmaker docs ")));
+  clack.intro(chalk11.bgCyan(chalk11.black(" wlmaker docs ")));
   const action = await clack.select({
     message: "What do you want to do?",
     options: [
@@ -2860,46 +3579,46 @@ async function docsInteractiveMode() {
         }
         const remoteUrl = "https://dc-wl-docs.web.app/development_workflow/";
         if (!remoteUrl) {
-          clack.outro(chalk9.red("Remote docs URL not configured. Set WL_DOCS_URL in your environment."));
+          clack.outro(chalk11.red("Remote docs URL not configured. Set WL_DOCS_URL in your environment."));
           return;
         }
-        clack.log.info(`Opening remote docs: ${chalk9.cyan(remoteUrl)}`);
-        execSync2(`open "${remoteUrl}"`, { stdio: "ignore" });
-        clack.outro(chalk9.green("Opened remote docs in browser"));
+        clack.log.info(`Opening remote docs: ${chalk11.cyan(remoteUrl)}`);
+        execSync3(`open "${remoteUrl}"`, { stdio: "ignore" });
+        clack.outro(chalk11.green("Opened remote docs in browser"));
         return;
       }
       const bookDir = detectBookDir(process.cwd());
       if (!bookDir) {
         clack.outro(
-          chalk9.red("No Docusaurus book/ directory found. Run from a monorepo root.")
+          chalk11.red("No Docusaurus book/ directory found. Run from a monorepo root.")
         );
         return;
       }
-      clack.log.info(`Serving docs from ${chalk9.cyan(bookDir)}`);
+      clack.log.info(`Serving docs from ${chalk11.cyan(bookDir)}`);
       await serveBook(bookDir);
       break;
     }
     case "commands": {
       const commands = discoverCommands(process.cwd());
       if (commands.length === 0) {
-        clack.outro(chalk9.yellow("No commands found. Run from a monorepo root."));
+        clack.outro(chalk11.yellow("No commands found. Run from a monorepo root."));
         return;
       }
-      clack.log.info(`Found ${chalk9.green(commands.length.toString())} command(s)`);
+      clack.log.info(`Found ${chalk11.green(commands.length.toString())} command(s)`);
       displayCommands(commands);
-      clack.outro(chalk9.green("Done!"));
+      clack.outro(chalk11.green("Done!"));
       break;
     }
     case "architecture": {
       const info = discoverArchitecture(process.cwd());
       if (!info) {
         clack.outro(
-          chalk9.yellow("No monorepo detected. Run from within a Melos monorepo.")
+          chalk11.yellow("No monorepo detected. Run from within a Melos monorepo.")
         );
         return;
       }
       displayArchitecture(info);
-      clack.outro(chalk9.green("Done!"));
+      clack.outro(chalk11.green("Done!"));
       break;
     }
   }
@@ -2908,12 +3627,12 @@ var SCREAMING_SNAKE_REGEX = /^[A-Z][A-Z0-9_]*$/;
 async function envVarFlow() {
   const monorepoRoot = findMonorepoRoot(process.cwd());
   if (!monorepoRoot) {
-    clack.outro(chalk9.red("Not inside a monorepo. Run from within a Melos monorepo."));
+    clack.outro(chalk11.red("Not inside a monorepo. Run from within a Melos monorepo."));
     return;
   }
   const apps = discoverAppsWithEnv(monorepoRoot);
   if (apps.length === 0) {
-    clack.outro(chalk9.red("No apps with env/ directory found in the monorepo."));
+    clack.outro(chalk11.red("No apps with env/ directory found in the monorepo."));
     return;
   }
   const variableName = await clack.text({
@@ -3017,14 +3736,14 @@ async function envVarFlow() {
       includeInAppConfig
     });
     genSpinner.stop("Done");
-    clack.outro(chalk9.green("Environment variable added!"));
+    clack.outro(chalk11.green("Environment variable added!"));
   } catch (error) {
     genSpinner.stop("Failed");
-    clack.outro(chalk9.red(`Error: ${error}`));
+    clack.outro(chalk11.red(`Error: ${error}`));
   }
 }
 async function interactiveMode() {
-  clack.intro(chalk9.bgCyan(chalk9.black(" wlmaker ")));
+  clack.intro(chalk11.bgCyan(chalk11.black(" wlmaker ")));
   const createType = await clack.select({
     message: "What do you want to create?",
     options: [
@@ -3035,11 +3754,21 @@ async function interactiveMode() {
         label: "Widgetbook Use-Case",
         hint: "Component showcase"
       },
+      {
+        value: "page",
+        label: "Page",
+        hint: "GoRoute + View with barrels"
+      },
       {
         value: "endpoint",
         label: "Endpoint",
         hint: "BFF Clean Architecture stack"
       },
+      {
+        value: "package",
+        label: "Package",
+        hint: "Create a new package in the monorepo"
+      },
       {
         value: "env-var",
         label: "Env Var",
@@ -3070,9 +3799,15 @@ async function interactiveMode() {
     case "usecase":
       await useCaseFlow();
       break;
+    case "page":
+      await pageFlow();
+      break;
     case "endpoint":
       await endpointFlow();
       break;
+    case "package":
+      await packageFlow();
+      break;
     case "env-var":
       await envVarFlow();
       break;
@@ -3082,6 +3817,288 @@ async function interactiveMode() {
   }
 }
 
+// src/mcp-server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ErrorCode,
+  ListToolsRequestSchema,
+  McpError
+} from "@modelcontextprotocol/sdk/types.js";
+async function runMcpServer() {
+  const server = new Server(
+    {
+      name: "wlmaker-cli",
+      version: "1.5.0"
+    },
+    {
+      capabilities: {
+        tools: {}
+      }
+    }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: [
+        {
+          name: "create_bloc",
+          description: "Create a new BLoC with Freezed sealed classes in the Flutter project",
+          inputSchema: {
+            type: "object",
+            properties: {
+              name: {
+                type: "string",
+                description: "BLoC name in snake_case (e.g. user_login)"
+              },
+              dir: {
+                type: "string",
+                description: "Target directory for the BLoC"
+              }
+            },
+            required: ["name"]
+          }
+        },
+        {
+          name: "create_widget",
+          description: "Create a new widget in the design system",
+          inputSchema: {
+            type: "object",
+            properties: {
+              name: {
+                type: "string",
+                description: "Widget name in snake_case (e.g. toggle)"
+              },
+              tier: {
+                type: "string",
+                description: "Tier: atom, molecule, organism, template",
+                enum: ["atom", "molecule", "organism", "template"]
+              },
+              dir: {
+                type: "string",
+                description: "Project root directory (optional)"
+              }
+            },
+            required: ["name", "tier"]
+          }
+        },
+        {
+          name: "create_page",
+          description: "Create a new page (GoRoute + View) with barrel updates",
+          inputSchema: {
+            type: "object",
+            properties: {
+              name: {
+                type: "string",
+                description: "Page name in snake_case (e.g. profile, order_detail)"
+              },
+              path: {
+                type: "string",
+                description: "Absolute path to the pages directory"
+              }
+            },
+            required: ["name", "path"]
+          }
+        },
+        {
+          name: "create_usecase",
+          description: "Create a Widgetbook use-case for an existing widget",
+          inputSchema: {
+            type: "object",
+            properties: {
+              name: {
+                type: "string",
+                description: "Widget name in snake_case (e.g. toggle)"
+              },
+              tier: {
+                type: "string",
+                description: "Tier: atom, molecule, organism, template",
+                enum: ["atom", "molecule", "organism", "template"]
+              },
+              dir: {
+                type: "string",
+                description: "Project root directory (optional)"
+              }
+            },
+            required: ["name", "tier"]
+          }
+        },
+        {
+          name: "create_endpoint",
+          description: "Generate Clean Architecture stack for a BFF endpoint",
+          inputSchema: {
+            type: "object",
+            properties: {
+              projectRoot: { type: "string", description: "Root directory of the BFF package" },
+              projectName: { type: "string", description: "Name of the BFF package" },
+              httpMethod: {
+                type: "string",
+                enum: ["GET", "POST", "PUT", "DELETE", "PATCH"],
+                description: "HTTP method"
+              },
+              endpointPath: { type: "string", description: "Endpoint path (e.g. /api/users/{id})" },
+              bffApiFile: { type: "string", description: "Absolute or relative path to the BFF API dart file" },
+              useCaseName: { type: "string", description: "UseCase name in snake_case" },
+              diTarget: { type: "string", description: "DI target (e.g. app_base, none)", default: "none" },
+              diLazySingleton: { type: "boolean", description: "Use @lazySingleton", default: true }
+            },
+            required: ["projectRoot", "projectName", "httpMethod", "endpointPath", "bffApiFile", "useCaseName"]
+          }
+        },
+        {
+          name: "create_package",
+          description: "Create a new package in the monorepo",
+          inputSchema: {
+            type: "object",
+            properties: {
+              monorepoRoot: { type: "string", description: "Root directory of the monorepo" },
+              packageName: { type: "string", description: "Package name in snake_case" }
+            },
+            required: ["monorepoRoot", "packageName"]
+          }
+        },
+        {
+          name: "create_env_var",
+          description: "Add an environment variable across the Flutter monorepo",
+          inputSchema: {
+            type: "object",
+            properties: {
+              monorepoRoot: { type: "string", description: "Root directory of the monorepo" },
+              variableName: { type: "string", description: "Variable name in SCREAMING_SNAKE_CASE" },
+              dartType: {
+                type: "string",
+                enum: ["String", "int", "bool", "List<String>"],
+                description: "Dart type"
+              },
+              defaultValue: { type: "string", description: "Default value (optional)" },
+              selectedApps: { type: "array", items: { type: "string" }, description: "List of apps to update" },
+              vendorsTargets: { type: "array", items: { type: "string" }, description: "List of vendor module packages" },
+              includeInRemoteConfig: { type: "boolean", description: "Include in Remote Config" },
+              includeInAppConfig: { type: "boolean", description: "Include in AppConfig entity" }
+            },
+            required: ["monorepoRoot", "variableName", "dartType", "selectedApps", "vendorsTargets", "includeInRemoteConfig", "includeInAppConfig"]
+          }
+        },
+        {
+          name: "docs_commands",
+          description: "Show Makefile & melos commands reference",
+          inputSchema: {
+            type: "object",
+            properties: {
+              dir: { type: "string", description: "Project root directory" }
+            },
+            required: ["dir"]
+          }
+        },
+        {
+          name: "docs_architecture",
+          description: "Display monorepo architecture info as JSON",
+          inputSchema: {
+            type: "object",
+            properties: {
+              dir: { type: "string", description: "Project root directory" }
+            },
+            required: ["dir"]
+          }
+        }
+      ]
+    };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    try {
+      if (request.params.name === "create_bloc") {
+        const { name, dir } = request.params.arguments;
+        const targetDir = dir || process.cwd();
+        await createBloc(name, { dir: targetDir, buildRunner: false });
+        return {
+          content: [{ type: "text", text: `Successfully created BLoC ${name} in ${targetDir}` }]
+        };
+      }
+      if (request.params.name === "create_widget") {
+        const { name, tier, dir } = request.params.arguments;
+        const projectRoot = dir || process.cwd();
+        await createWidget(name, tier, { projectRoot, pattern: void 0 });
+        try {
+          await createUseCase(name, tier, { projectRoot, buildRunner: false });
+          return {
+            content: [{ type: "text", text: `Successfully created Widget ${name} (${tier}) and its UseCase in ${projectRoot}` }]
+          };
+        } catch {
+          return {
+            content: [{ type: "text", text: `Successfully created Widget ${name} (${tier}) in ${projectRoot} (UseCase creation skipped/failed)` }]
+          };
+        }
+      }
+      if (request.params.name === "create_page") {
+        const { name, path: path16 } = request.params.arguments;
+        await createPage(name, { pagesPath: path16 });
+        return {
+          content: [{ type: "text", text: `Successfully created Page ${name} in ${path16}` }]
+        };
+      }
+      if (request.params.name === "create_usecase") {
+        const { name, tier, dir } = request.params.arguments;
+        const projectRoot = dir || process.cwd();
+        await createUseCase(name, tier, { projectRoot, buildRunner: false });
+        return {
+          content: [{ type: "text", text: `Successfully created UseCase for ${name} (${tier}) in ${projectRoot}` }]
+        };
+      }
+      if (request.params.name === "create_endpoint") {
+        const args = request.params.arguments;
+        await createEndpoint({
+          ...args,
+          diTarget: args.diTarget || "none",
+          diLazySingleton: args.diLazySingleton ?? true
+        });
+        return {
+          content: [{ type: "text", text: `Successfully generated endpoint stack for ${args.useCaseName}` }]
+        };
+      }
+      if (request.params.name === "create_package") {
+        const { monorepoRoot, packageName } = request.params.arguments;
+        await createPackage({ monorepoRoot, packageName });
+        return {
+          content: [{ type: "text", text: `Successfully created package ${packageName} in ${monorepoRoot}/packages` }]
+        };
+      }
+      if (request.params.name === "create_env_var") {
+        const args = request.params.arguments;
+        await createEnvVar(args);
+        return {
+          content: [{ type: "text", text: `Successfully added environment variable ${args.variableName}` }]
+        };
+      }
+      if (request.params.name === "docs_commands") {
+        const { dir } = request.params.arguments;
+        const commands = discoverCommands(dir || process.cwd());
+        return {
+          content: [{ type: "text", text: JSON.stringify(commands, null, 2) }]
+        };
+      }
+      if (request.params.name === "docs_architecture") {
+        const { dir } = request.params.arguments;
+        const info = discoverArchitecture(dir || process.cwd());
+        if (!info) {
+          return { content: [{ type: "text", text: "No monorepo detected." }] };
+        }
+        return {
+          content: [{ type: "text", text: JSON.stringify(info, null, 2) }]
+        };
+      }
+      throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${request.params.name}`);
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: `Error: ${error?.message || String(error)}` }],
+        isError: true
+      };
+    }
+  });
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error("wlmaker-cli MCP server running on stdio");
+}
+
 // src/cli.ts
 var require2 = createRequire(import.meta.url);
 var pkg = require2("../package.json");
@@ -3098,7 +4115,7 @@ program.command("bloc").description("Create a new BLoC with Freezed sealed class
     try {
       await createBloc(name, options);
     } catch (error) {
-      console.error(chalk10.red(`Error: ${error}`));
+      console.error(chalk12.red(`Error: ${error}`));
       process.exit(1);
     }
   }
@@ -3115,12 +4132,12 @@ program.command("widget").description("Create a new widget in the design system"
           projectRoot: options.dir,
           buildRunner: false
         });
-        console.log(chalk10.green("Widgetbook use-case created"));
+        console.log(chalk12.green("Widgetbook use-case created"));
       } catch {
-        console.log(chalk10.yellow("Use-case skipped (may already exist)"));
+        console.log(chalk12.yellow("Use-case skipped (may already exist)"));
       }
     } catch (error) {
-      console.error(chalk10.red(`Error: ${error}`));
+      console.error(chalk12.red(`Error: ${error}`));
       process.exit(1);
     }
   }
@@ -3133,15 +4150,30 @@ program.command("usecase").description("Create a Widgetbook use-case for an exis
         buildRunner: options.buildRunner
       });
     } catch (error) {
-      console.error(chalk10.red(`Error: ${error}`));
+      console.error(chalk12.red(`Error: ${error}`));
+      process.exit(1);
+    }
+  }
+);
+program.command("page").description("Create a new page (GoRoute + View) with barrel updates").argument("[name]", "Page name in snake_case (e.g. profile, order_detail)").option("-p, --path <path>", "absolute path to the pages directory").action(
+  async (name, options) => {
+    if (!name || !options.path) {
+      await pageFlow(name, options.path);
+      return;
+    }
+    try {
+      await createPage(name, { pagesPath: options.path });
+    } catch (error) {
+      console.error(chalk12.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);
+  await endpointFlow();
+});
+program.command("package").description("Create a new package in the monorepo").action(async () => {
+  await packageFlow();
 });
 program.command("env-var").description("Add an environment variable across the Flutter monorepo").action(async () => {
   await envVarFlow();
@@ -3150,30 +4182,36 @@ 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(chalk10.red("No Docusaurus book/ directory found. Run from a monorepo root."));
+    console.error(chalk12.red("No Docusaurus book/ directory found. Run from a monorepo root."));
     process.exit(1);
   }
-  console.log(chalk10.cyan(`Serving docs from ${bookDir}`));
+  console.log(chalk12.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(chalk10.yellow("No commands found. Run from a monorepo root."));
+    console.log(chalk12.yellow("No commands found. Run from a monorepo root."));
     return;
   }
-  console.log(chalk10.green(`Found ${commands.length} command(s)
+  console.log(chalk12.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(chalk10.yellow("No monorepo detected. Run from within a Melos monorepo."));
+    console.log(chalk12.yellow("No monorepo detected. Run from within a Melos monorepo."));
     return;
   }
   displayArchitecture(info);
 });
+program.command("mcp").description("Start the wlmaker MCP server (used automatically by AI clients)").action(async () => {
+  await runMcpServer();
+});
+program.command("mcp-install").description("Manually install/register the wlmaker MCP server into compatible clients (Claude, Cursor, Cline)").action(async () => {
+  await installMcpServer();
+});
 docsCmd.action(async () => {
   await docsInteractiveMode();
 });