wlmaker 1.1.2 → 1.2.0

package/dist/cli.mjs

@@ -3,7 +3,7 @@
 // src/cli.ts
 import { createRequire } from "module";
 import { Command } from "commander";
-import chalk3 from "chalk";
+import chalk5 from "chalk";
 
 // src/core/create-bloc.ts
 import * as fs3 from "fs";
@@ -72,6 +72,20 @@ function updateBarrelFile(parentDir, name) {
     fs.writeFileSync(barrelPath, exportLine + "\n");
   }
 }
+function updateSortedBarrelFile(tierDir, barrelFileName, exportLine) {
+  const barrelPath = path.join(tierDir, barrelFileName);
+  let lines = [];
+  if (fs.existsSync(barrelPath)) {
+    const content = fs.readFileSync(barrelPath, "utf8");
+    lines = content.split("\n").filter((l) => l.trim().length > 0);
+  }
+  if (lines.includes(exportLine)) {
+    return;
+  }
+  lines.push(exportLine);
+  lines.sort();
+  fs.writeFileSync(barrelPath, lines.join("\n") + "\n");
+}
 
 // src/core/build-runner.ts
 import { spawn } from "child_process";
@@ -144,12 +158,70 @@ async function createBloc(name, options) {
   }
 }
 
-// src/interactive.ts
+// src/core/create-widget.ts
+import * as fs6 from "fs";
+import * as path6 from "path";
+import chalk2 from "chalk";
+import { pascalCase as pascalCase2 } from "change-case";
+
+// src/core/tier.ts
+var VALID_TIERS = ["atom", "molecule", "organism", "template"];
+var TIER_PATTERNS = {
+  atom: ["single-public", "single-factory", "subdirectory-parts"],
+  molecule: ["single", "subdirectory-parts", "subdirectory-widgets"],
+  organism: ["subdirectory-show", "single"],
+  template: ["simple", "config-data-callbacks"]
+};
+var TIER_PLURAL = {
+  atom: "atoms",
+  molecule: "molecules",
+  organism: "organisms",
+  template: "templates"
+};
+var TIER_LABELS = {
+  atom: "Atom",
+  molecule: "Molecule",
+  organism: "Organism",
+  template: "Template"
+};
+var PATTERN_LABELS = {
+  "single-public": "Single file, public constructor",
+  "single-factory": "Single file, private constructor + factories",
+  "subdirectory-parts": "Subdirectory with part files",
+  single: "Single file (StatefulWidget)",
+  "subdirectory-widgets": "Subdirectory with widgets/ and utils/",
+  "subdirectory-show": "Subdirectory with static show() + parts",
+  simple: "Template simple (i18n + body + skeleton)",
+  "config-data-callbacks": "Template with Config/Data/Callbacks"
+};
+function normalizeTier(input) {
+  const normalized = input.toLowerCase().replace(/s$/, "");
+  if (VALID_TIERS.includes(normalized)) {
+    return normalized;
+  }
+  throw new Error(
+    `Invalid tier "${input}". Valid tiers: ${VALID_TIERS.join(", ")}`
+  );
+}
+function tierPlural(tier) {
+  return TIER_PLURAL[tier];
+}
+function tierLabel(tier) {
+  return TIER_LABELS[tier];
+}
+function getValidPatterns(tier) {
+  return TIER_PATTERNS[tier];
+}
+function getDefaultPattern(tier) {
+  return TIER_PATTERNS[tier][0];
+}
+function patternLabel(pattern) {
+  return PATTERN_LABELS[pattern] ?? pattern;
+}
+
+// src/core/design-system-analyzer.ts
 import * as fs5 from "fs";
-import * as os from "os";
 import * as path5 from "path";
-import * as clack from "@clack/prompts";
-import chalk2 from "chalk";
 
 // src/core/project-analyzer.ts
 import * as fs4 from "fs";
@@ -253,14 +325,813 @@ function discoverProjects(searchDir, maxDepth = 2) {
   return projects.sort((a, b) => a.projectName.localeCompare(b.projectName));
 }
 
-// src/interactive.ts
+// src/core/design-system-analyzer.ts
+function detectDesignSystem(projectRoot) {
+  const monorepoRoot = findMonorepoRoot(projectRoot);
+  if (monorepoRoot) {
+    const dsDir = path5.join(
+      monorepoRoot,
+      "packages",
+      "design_system",
+      "lib",
+      "wl_design_system"
+    );
+    if (fs5.existsSync(dsDir)) {
+      const widgetbookDir = path5.join(monorepoRoot, "apps", "widgetbook");
+      return {
+        componentsDir: dsDir,
+        widgetbookDir: fs5.existsSync(widgetbookDir) ? widgetbookDir : void 0,
+        availableTiers: discoverTiers(dsDir)
+      };
+    }
+  }
+  const standaloneDir = path5.join(projectRoot, "lib", "wl_design_system");
+  if (fs5.existsSync(standaloneDir)) {
+    const widgetbookDir = path5.join(
+      path5.dirname(projectRoot),
+      "widgetbook"
+    );
+    return {
+      componentsDir: standaloneDir,
+      widgetbookDir: fs5.existsSync(widgetbookDir) ? widgetbookDir : void 0,
+      availableTiers: discoverTiers(standaloneDir)
+    };
+  }
+  return null;
+}
+function discoverTiers(componentsDir) {
+  const tiers = [];
+  const tierSet = new Set(VALID_TIERS.map((t) => tierPlural(t)));
+  try {
+    const entries = fs5.readdirSync(componentsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && tierSet.has(entry.name)) {
+        tiers.push(entry.name);
+      }
+    }
+  } catch {
+  }
+  return tiers;
+}
+function widgetExists(componentsDir, tierPluralName, widgetName) {
+  const tierDir = path5.join(componentsDir, tierPluralName);
+  const flatFile = path5.join(tierDir, `${widgetName}.dart`);
+  if (fs5.existsSync(flatFile)) return true;
+  const subDir = path5.join(tierDir, widgetName);
+  if (fs5.existsSync(subDir)) return true;
+  return false;
+}
+
+// src/core/widget-templates.ts
+function atomTemplateA(name, pascal) {
+  return `import 'package:flutter/material.dart';
+
+class Wl${pascal} extends StatelessWidget {
+  const Wl${pascal}({super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = context.theme;
+    return const SizedBox.shrink();
+  }
+}
+`;
+}
+function atomTemplateB(name, pascal) {
+  return `import 'package:flutter/material.dart';
+
+enum Wl${pascal}Variant {
+  primary,
+  secondary,
+}
+
+class Wl${pascal} extends StatelessWidget {
+  final Wl${pascal}Variant variant;
+
+  const Wl${pascal}._internal({required this.variant, super.key});
+
+  factory Wl${pascal}.primary({Key? key}) =>
+      Wl${pascal}._internal(variant: Wl${pascal}Variant.primary, key: key);
+
+  factory Wl${pascal}.secondary({Key? key}) =>
+      Wl${pascal}._internal(variant: Wl${pascal}Variant.secondary, key: key);
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = context.theme;
+    return const SizedBox.shrink();
+  }
+}
+`;
+}
+function atomTemplateC(name, pascal) {
+  return {
+    main: `import 'package:flutter/material.dart';
+
+part '${name}_sizes.dart';
+
+class Wl${pascal} extends StatelessWidget {
+  final Wl${pascal}Size size;
+
+  const Wl${pascal}({this.size = Wl${pascal}Size.md, super.key});
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = context.theme;
+    return SizedBox(
+      width: size.width,
+      height: size.height,
+      child: const SizedBox.shrink(),
+    );
+  }
+}
+`,
+    sizes: `part of '${name}.dart';
+
+enum _Wl${pascal}Size {
+  sm,
+  md,
+  lg,
+}
+
+extension _Wl${pascal}SizeExt on _Wl${pascal}Size {
+  double get width => switch (this) {
+        _Wl${pascal}Size.sm => 16,
+        _Wl${pascal}Size.md => 24,
+        _Wl${pascal}Size.lg => 32,
+      };
+
+  double get height => switch (this) {
+        _Wl${pascal}Size.sm => 16,
+        _Wl${pascal}Size.md => 24,
+        _Wl${pascal}Size.lg => 32,
+      };
+}
+`
+  };
+}
+function moleculeTemplateA(name, pascal) {
+  return `import 'package:flutter/material.dart';
+
+enum Wl${pascal}Variant {
+  primary,
+  secondary,
+}
+
+class Wl${pascal} extends StatefulWidget {
+  final Wl${pascal}Variant variant;
+
+  const Wl${pascal}({
+    this.variant = Wl${pascal}Variant.primary,
+    super.key,
+  });
+
+  @override
+  State<Wl${pascal}> createState() => _Wl${pascal}State();
+}
+
+class _Wl${pascal}State extends State<Wl${pascal}> {
+  @override
+  Widget build(BuildContext context) {
+    final theme = context.theme;
+    return const SizedBox.shrink();
+  }
+}
+`;
+}
+function moleculeTemplateB(name, pascal) {
+  return {
+    main: `import 'package:flutter/material.dart';
+
+part '${name}_type.dart';
+
+class Wl${pascal} extends StatefulWidget {
+  final Wl${pascal}Variant variant;
+
+  const Wl${pascal}({
+    this.variant = Wl${pascal}Variant.primary,
+    super.key,
+  });
+
+  @override
+  State<Wl${pascal}> createState() => _Wl${pascal}State();
+}
+
+class _Wl${pascal}State extends State<Wl${pascal}> {
+  @override
+  Widget build(BuildContext context) {
+    final theme = context.theme;
+    return const SizedBox.shrink();
+  }
+}
+`,
+    type: `part of '${name}.dart';
+
+enum Wl${pascal}Variant {
+  primary,
+  secondary,
+}
+
+extension Wl${pascal}VariantExt on Wl${pascal}Variant {
+  bool get isPrimary => this == Wl${pascal}Variant.primary;
+}
+`
+  };
+}
+function moleculeTemplateC(name, pascal) {
+  return `import 'package:flutter/material.dart';
+
+class Wl${pascal} extends StatefulWidget {
+  const Wl${pascal}({super.key});
+
+  @override
+  State<Wl${pascal}> createState() => _Wl${pascal}State();
+}
+
+class _Wl${pascal}State extends State<Wl${pascal}> {
+  @override
+  Widget build(BuildContext context) {
+    final theme = context.theme;
+    return const SizedBox.shrink();
+  }
+}
+`;
+}
+function organismTemplateA(name, pascal) {
+  return {
+    main: `import 'package:flutter/material.dart';
+
+part '${name}_content.dart';
+
+class Wl${pascal} {
+  Wl${pascal}._();
+
+  static Future<T?> show<T>({
+    required BuildContext context,
+  }) {
+    return showDialog<T>(
+      context: context,
+      builder: (context) => _Wl${pascal}Content(),
+    );
+  }
+}
+`,
+    content: `part of '${name}.dart';
+
+class _Wl${pascal}Content extends StatelessWidget {
+  @override
+  Widget build(BuildContext context) {
+    final theme = context.theme;
+    return const SizedBox.shrink();
+  }
+}
+`
+  };
+}
+function organismTemplateB(name, pascal) {
+  return `import 'package:flutter/material.dart';
+
+class Wl${pascal} extends StatefulWidget {
+  const Wl${pascal}({super.key});
+
+  @override
+  State<Wl${pascal}> createState() => _Wl${pascal}State();
+}
+
+class _Wl${pascal}State extends State<Wl${pascal}> {
+  @override
+  Widget build(BuildContext context) {
+    final theme = context.theme;
+    return const SizedBox.shrink();
+  }
+}
+`;
+}
+function templateA(name, pascal) {
+  return {
+    main: `import 'package:flutter/material.dart';
+
+part '${name}_i18n.dart';
+part '${name}_body.dart';
+part '${name}_skeleton.dart';
+
+class Wl${pascal}Template extends StatefulWidget {
+  const Wl${pascal}Template({super.key});
+
+  @override
+  State<Wl${pascal}Template> createState() => _Wl${pascal}TemplateState();
+}
+
+class _Wl${pascal}TemplateState extends State<Wl${pascal}Template> {
+  bool _isLoading = true;
+
+  @override
+  void initState() {
+    super.initState();
+    _loadData();
+  }
+
+  Future<void> _loadData() async {
+    // TODO: Load data
+    setState(() => _isLoading = false);
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(title: Text(Wl${pascal}I18n.title)),
+      body: AnimatedSwitcher(
+        duration: const Duration(milliseconds: 300),
+        child: _isLoading
+            ? const _Wl${pascal}Skeleton()
+            : const _Wl${pascal}Body(),
+      ),
+    );
+  }
+}
+`,
+    i18n: `part of '${name}_template.dart';
+
+class Wl${pascal}I18n extends Equatable {
+  final String title;
+
+  const Wl${pascal}I18n({
+    this.title = '',
+  });
+
+  static const empty = Wl${pascal}I18n();
+
+  @override
+  List<Object?> get props => [title];
+}
+`,
+    body: `part of '${name}_template.dart';
+
+class _Wl${pascal}Body extends StatelessWidget {
+  const _Wl${pascal}Body();
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = context.theme;
+    return const SizedBox.shrink();
+  }
+}
+`,
+    skeleton: `part of '${name}_template.dart';
+
+class _Wl${pascal}Skeleton extends StatelessWidget {
+  const _Wl${pascal}Skeleton();
+
+  @override
+  Widget build(BuildContext context) {
+    return const Center(
+      child: CircularProgressIndicator(),
+    );
+  }
+}
+`
+  };
+}
+function templateB(name, pascal) {
+  return {
+    main: `import 'package:flutter/material.dart';
+
+import 'contracts/${name}_callbacks.dart';
+import 'contracts/${name}_config.dart';
+import 'contracts/${name}_data.dart';
+
+part '${name}_i18n.dart';
+part '${name}_body.dart';
+part '${name}_skeleton.dart';
+
+class Wl${pascal}Template extends StatefulWidget {
+  final Wl${pascal}Config config;
+  final Wl${pascal}Callbacks callbacks;
+
+  const Wl${pascal}Template({
+    required this.config,
+    required this.callbacks,
+    super.key,
+  });
+
+  @override
+  State<Wl${pascal}Template> createState() => _Wl${pascal}TemplateState();
+}
+
+class _Wl${pascal}TemplateState extends State<Wl${pascal}Template> {
+  Wl${pascal}Data _data = const Wl${pascal}Data();
+  bool _isLoading = true;
+
+  @override
+  void initState() {
+    super.initState();
+    _loadData();
+  }
+
+  Future<void> _loadData() async {
+    // TODO: Load data
+    setState(() => _isLoading = false);
+  }
+
+  @override
+  Widget build(BuildContext context) {
+    return Scaffold(
+      appBar: AppBar(title: Text(widget.config.i18n.title)),
+      body: AnimatedSwitcher(
+        duration: const Duration(milliseconds: 300),
+        child: _isLoading
+            ? const _Wl${pascal}Skeleton()
+            : _Wl${pascal}Body(
+                data: _data,
+                callbacks: widget.callbacks,
+              ),
+      ),
+    );
+  }
+}
+`,
+    i18n: `part of '${name}_template.dart';
+
+class Wl${pascal}I18n extends Equatable {
+  final String title;
+
+  const Wl${pascal}I18n({
+    this.title = '',
+  });
+
+  static const empty = Wl${pascal}I18n();
+
+  @override
+  List<Object?> get props => [title];
+}
+`,
+    body: `part of '${name}_template.dart';
+
+class _Wl${pascal}Body extends StatelessWidget {
+  final Wl${pascal}Data data;
+  final Wl${pascal}Callbacks callbacks;
+
+  const _Wl${pascal}Body({
+    required this.data,
+    required this.callbacks,
+  });
+
+  @override
+  Widget build(BuildContext context) {
+    final theme = context.theme;
+    return const SizedBox.shrink();
+  }
+}
+`,
+    skeleton: `part of '${name}_template.dart';
+
+class _Wl${pascal}Skeleton extends StatelessWidget {
+  const _Wl${pascal}Skeleton();
+
+  @override
+  Widget build(BuildContext context) {
+    return const Center(
+      child: CircularProgressIndicator(),
+    );
+  }
+}
+`,
+    callbacks: `import 'package:flutter/material.dart';
+
+class Wl${pascal}Callbacks {
+  final VoidCallback onBack;
+  final VoidCallback onRetry;
+
+  const Wl${pascal}Callbacks({
+    required this.onBack,
+    required this.onRetry,
+  });
+}
+`,
+    config: `import 'package:flutter/material.dart';
+import '../${name}_template.dart';
+
+class Wl${pascal}Config extends Equatable {
+  final Wl${pascal}I18n i18n;
+  final bool showAppBar;
+
+  const Wl${pascal}Config({
+    this.i18n = Wl${pascal}I18n.empty,
+    this.showAppBar = true,
+  });
+
+  @override
+  List<Object?> get props => [i18n, showAppBar];
+}
+`,
+    data: `import 'package:flutter/material.dart';
+
+class Wl${pascal}Data extends Equatable {
+  const Wl${pascal}Data();
+
+  @override
+  List<Object?> get props => [];
+}
+`
+  };
+}
+function useCaseTemplate(name, pascal, tierPlural3) {
+  return `import 'package:widgetbook/widgetbook.dart';
+import 'package:wl_design_system/${tierPlural3}/wl_${name}.dart';
+
+WidgetbookUseCase wl${pascal}UseCase(BuildContext context) {
+  return WidgetbookUseCase(
+    name: 'Wl${pascal}',
+    builder: (context) => const Wl${pascal}(),
+  );
+}
+`;
+}
+
+// src/core/create-widget.ts
 var SNAKE_CASE_REGEX2 = /^[a-z][a-z0-9_]*$/;
+async function createWidget(name, tierInput, options) {
+  let cleanName = name;
+  if (cleanName.startsWith("wl_")) {
+    cleanName = cleanName.slice(3);
+  }
+  if (!cleanName || !SNAKE_CASE_REGEX2.test(cleanName)) {
+    throw new Error(
+      "Name must be snake_case (lowercase letters, digits, underscores)."
+    );
+  }
+  const tier = normalizeTier(tierInput);
+  const plural = tierPlural(tier);
+  const pascal = pascalCase2(cleanName);
+  const fileName = `wl_${cleanName}`;
+  const ds = detectDesignSystem(options.projectRoot);
+  if (!ds) {
+    throw new Error(
+      "Could not detect design system. Ensure wl_design_system/ directory exists."
+    );
+  }
+  const tierDir = path6.join(ds.componentsDir, plural);
+  if (!fs6.existsSync(tierDir)) {
+    fs6.mkdirSync(tierDir, { recursive: true });
+  }
+  const pattern = options.pattern ?? getDefaultPattern(tier);
+  const flatPath = path6.join(tierDir, `${fileName}.dart`);
+  const subDirPath = path6.join(tierDir, fileName);
+  if (fs6.existsSync(flatPath) || fs6.existsSync(subDirPath)) {
+    throw new Error(`Widget "${fileName}" already exists in ${plural}/.`);
+  }
+  switch (tier) {
+    case "atom":
+      createAtomFiles(tierDir, cleanName, pascal, fileName, pattern);
+      break;
+    case "molecule":
+      createMoleculeFiles(tierDir, cleanName, pascal, fileName, pattern);
+      break;
+    case "organism":
+      createOrganismFiles(tierDir, cleanName, pascal, fileName, pattern);
+      break;
+    case "template":
+      createTemplateFiles(tierDir, cleanName, pascal, fileName, pattern);
+      break;
+  }
+  const barrelFileName = `${plural}.dart`;
+  const exportLine = tier === "template" ? `export '${cleanName}/wl_${cleanName}_template.dart';` : `export '${fileName}.dart';`;
+  updateSortedBarrelFile(tierDir, barrelFileName, exportLine);
+  console.log(chalk2.green(`Widget "Wl${pascal}" created in ${plural}/`));
+}
+function createAtomFiles(tierDir, name, pascal, fileName, pattern) {
+  switch (pattern) {
+    case "single-public": {
+      fs6.writeFileSync(
+        path6.join(tierDir, `${fileName}.dart`),
+        atomTemplateA(name, pascal)
+      );
+      break;
+    }
+    case "single-factory": {
+      fs6.writeFileSync(
+        path6.join(tierDir, `${fileName}.dart`),
+        atomTemplateB(name, pascal)
+      );
+      break;
+    }
+    case "subdirectory-parts": {
+      const dir = path6.join(tierDir, fileName);
+      fs6.mkdirSync(dir, { recursive: true });
+      const tpl = atomTemplateC(name, pascal);
+      fs6.writeFileSync(path6.join(dir, `${fileName}.dart`), tpl.main);
+      fs6.writeFileSync(
+        path6.join(dir, `${fileName}_sizes.dart`),
+        tpl.sizes
+      );
+      break;
+    }
+    default:
+      throw new Error(`Unknown atom pattern: ${pattern}`);
+  }
+}
+function createMoleculeFiles(tierDir, name, pascal, fileName, pattern) {
+  switch (pattern) {
+    case "single": {
+      fs6.writeFileSync(
+        path6.join(tierDir, `${fileName}.dart`),
+        moleculeTemplateA(name, pascal)
+      );
+      break;
+    }
+    case "subdirectory-parts": {
+      const dir = path6.join(tierDir, fileName);
+      fs6.mkdirSync(dir, { recursive: true });
+      const tpl = moleculeTemplateB(name, pascal);
+      fs6.writeFileSync(path6.join(dir, `${fileName}.dart`), tpl.main);
+      fs6.writeFileSync(
+        path6.join(dir, `${fileName}_type.dart`),
+        tpl.type
+      );
+      break;
+    }
+    case "subdirectory-widgets": {
+      const dir = path6.join(tierDir, fileName);
+      fs6.mkdirSync(dir, { recursive: true });
+      fs6.mkdirSync(path6.join(dir, "widgets"), { recursive: true });
+      fs6.mkdirSync(path6.join(dir, "utils"), { recursive: true });
+      fs6.writeFileSync(
+        path6.join(dir, `${fileName}.dart`),
+        moleculeTemplateC(name, pascal)
+      );
+      break;
+    }
+    default:
+      throw new Error(`Unknown molecule pattern: ${pattern}`);
+  }
+}
+function createOrganismFiles(tierDir, name, pascal, fileName, pattern) {
+  switch (pattern) {
+    case "subdirectory-show": {
+      const dir = path6.join(tierDir, fileName);
+      fs6.mkdirSync(dir, { recursive: true });
+      const tpl = organismTemplateA(name, pascal);
+      fs6.writeFileSync(path6.join(dir, `${fileName}.dart`), tpl.main);
+      fs6.writeFileSync(
+        path6.join(dir, `${fileName}_content.dart`),
+        tpl.content
+      );
+      break;
+    }
+    case "single": {
+      fs6.writeFileSync(
+        path6.join(tierDir, `${fileName}.dart`),
+        organismTemplateB(name, pascal)
+      );
+      break;
+    }
+    default:
+      throw new Error(`Unknown organism pattern: ${pattern}`);
+  }
+}
+function createTemplateFiles(tierDir, name, pascal, fileName, pattern) {
+  const dir = path6.join(tierDir, name);
+  fs6.mkdirSync(dir, { recursive: true });
+  switch (pattern) {
+    case "simple": {
+      const tpl = templateA(name, pascal);
+      fs6.writeFileSync(
+        path6.join(dir, `wl_${name}_template.dart`),
+        tpl.main
+      );
+      fs6.writeFileSync(
+        path6.join(dir, `wl_${name}_i18n.dart`),
+        tpl.i18n
+      );
+      fs6.writeFileSync(path6.join(dir, `wl_${name}_body.dart`), tpl.body);
+      fs6.writeFileSync(
+        path6.join(dir, `wl_${name}_skeleton.dart`),
+        tpl.skeleton
+      );
+      break;
+    }
+    case "config-data-callbacks": {
+      const tpl = templateB(name, pascal);
+      fs6.writeFileSync(
+        path6.join(dir, `wl_${name}_template.dart`),
+        tpl.main
+      );
+      fs6.writeFileSync(
+        path6.join(dir, `wl_${name}_i18n.dart`),
+        tpl.i18n
+      );
+      fs6.writeFileSync(path6.join(dir, `wl_${name}_body.dart`), tpl.body);
+      fs6.writeFileSync(
+        path6.join(dir, `wl_${name}_skeleton.dart`),
+        tpl.skeleton
+      );
+      const contractsDir = path6.join(dir, "contracts");
+      fs6.mkdirSync(contractsDir, { recursive: true });
+      fs6.writeFileSync(
+        path6.join(contractsDir, `wl_${name}_callbacks.dart`),
+        tpl.callbacks
+      );
+      fs6.writeFileSync(
+        path6.join(contractsDir, `wl_${name}_config.dart`),
+        tpl.config
+      );
+      fs6.writeFileSync(
+        path6.join(contractsDir, `wl_${name}_data.dart`),
+        tpl.data
+      );
+      break;
+    }
+    default:
+      throw new Error(`Unknown template pattern: ${pattern}`);
+  }
+}
+
+// src/core/create-usecase.ts
+import * as fs7 from "fs";
+import * as path7 from "path";
+import chalk3 from "chalk";
+import { pascalCase as pascalCase3 } from "change-case";
+var SNAKE_CASE_REGEX3 = /^[a-z][a-z0-9_]*$/;
+async function createUseCase(name, tierInput, options) {
+  let cleanName = name;
+  if (cleanName.startsWith("wl_")) {
+    cleanName = cleanName.slice(3);
+  }
+  if (!cleanName || !SNAKE_CASE_REGEX3.test(cleanName)) {
+    throw new Error(
+      "Name must be snake_case (lowercase letters, digits, underscores)."
+    );
+  }
+  const tier = normalizeTier(tierInput);
+  const plural = tierPlural(tier);
+  const pascal = pascalCase3(cleanName);
+  const fileName = `wl_${cleanName}`;
+  const ds = detectDesignSystem(options.projectRoot);
+  if (!ds) {
+    throw new Error(
+      "Could not detect design system. Ensure wl_design_system/ directory exists."
+    );
+  }
+  if (!ds.widgetbookDir) {
+    throw new Error(
+      "Could not detect widgetbook package. Ensure apps/widgetbook/ exists."
+    );
+  }
+  if (!widgetExists(ds.componentsDir, plural, fileName)) {
+    throw new Error(
+      `Widget "${fileName}" not found in ${plural}/. Create the widget first.`
+    );
+  }
+  const useCasesDir = path7.join(
+    ds.widgetbookDir,
+    "lib",
+    "usecases",
+    "wl_design_system"
+  );
+  if (!fs7.existsSync(useCasesDir)) {
+    fs7.mkdirSync(useCasesDir, { recursive: true });
+  }
+  const useCasePath = path7.join(useCasesDir, `${fileName}.dart`);
+  if (fs7.existsSync(useCasePath)) {
+    throw new Error(`Use-case "${fileName}.dart" already exists.`);
+  }
+  fs7.writeFileSync(
+    useCasePath,
+    useCaseTemplate(cleanName, pascal, plural)
+  );
+  console.log(
+    chalk3.green(
+      `Use-case for "Wl${pascal}" created in widgetbook/lib/usecases/wl_design_system/`
+    )
+  );
+  if (options.buildRunner) {
+    if (hasBuildRunner(ds.widgetbookDir)) {
+      console.log(chalk3.blue("Running build_runner..."));
+      await runBuildRunner(ds.widgetbookDir);
+      console.log(chalk3.green("build_runner completed."));
+    } else {
+      console.log(
+        chalk3.yellow(
+          "Skipping build_runner (no build_runner dependency found in widgetbook)."
+        )
+      );
+    }
+  }
+}
+
+// src/interactive.ts
+import * as fs8 from "fs";
+import * as os from "os";
+import * as path8 from "path";
+import * as clack from "@clack/prompts";
+import chalk4 from "chalk";
+var SNAKE_CASE_REGEX4 = /^[a-z][a-z0-9_]*$/;
 async function resolveProject() {
   const s = clack.spinner();
   s.start("Analyzing current directory...");
   const cwdProject = analyzeProject(process.cwd());
   if (cwdProject && (cwdProject.hasFreezed || cwdProject.hasBloc)) {
-    s.stop(`Found ${chalk2.green(cwdProject.projectName)}`);
+    s.stop(`Found ${chalk4.green(cwdProject.projectName)}`);
     return cwdProject;
   }
   s.message("Looking for Melos monorepo...");
@@ -273,8 +1144,8 @@ async function resolveProject() {
     }
   }
   s.message("Scanning for Flutter projects...");
-  const homeDev = path5.join(os.homedir(), "Development");
-  if (fs5.existsSync(homeDev)) {
+  const homeDev = path8.join(os.homedir(), "Development");
+  if (fs8.existsSync(homeDev)) {
     const projects = discoverProjects(homeDev, 2);
     if (projects.length > 0) {
       s.stop(`Found ${projects.length} Flutter project(s)`);
@@ -282,12 +1153,12 @@ async function resolveProject() {
     }
   }
   s.stop("No Flutter projects found");
-  clack.outro(chalk2.red("Could not find any Flutter project with freezed or flutter_bloc."));
+  clack.outro(chalk4.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 ${chalk2.green(projects[0].projectName)}`);
+    clack.log.info(`Using ${chalk4.green(projects[0].projectName)}`);
     return projects[0];
   }
   const selected = await clack.select({
@@ -295,7 +1166,7 @@ async function selectPackage(projects) {
     options: projects.map((p) => ({
       value: p,
       label: p.projectName,
-      hint: path5.relative(os.homedir(), p.projectRoot)
+      hint: path8.relative(os.homedir(), p.projectRoot)
     }))
   });
   if (clack.isCancel(selected)) {
@@ -304,16 +1175,14 @@ async function selectPackage(projects) {
   }
   return selected;
 }
-async function interactiveMode() {
-  clack.intro(chalk2.bgCyan(chalk2.black(" wlmaker ")));
-  const project = await resolveProject();
-  if (!project) return;
+async function blocFlow(project) {
   const name = await clack.text({
     message: "BLoC name (snake_case)",
     placeholder: "e.g. user_login",
     validate: (value) => {
       if (!value.trim()) return "Name is required";
-      if (!SNAKE_CASE_REGEX2.test(value)) return "Must be snake_case (lowercase, digits, underscores)";
+      if (!SNAKE_CASE_REGEX4.test(value))
+        return "Must be snake_case (lowercase, digits, underscores)";
     }
   });
   if (clack.isCancel(name)) {
@@ -345,15 +1214,18 @@ async function interactiveMode() {
         clack.cancel("Cancelled");
         return;
       }
-      targetDir = path5.resolve(customPath);
+      targetDir = path8.resolve(customPath);
     } else {
-      targetDir = path5.join(project.projectRoot, "lib", "features", feature);
+      targetDir = path8.join(project.projectRoot, "lib", "features", feature);
     }
-  } else if (fs5.existsSync(path5.join(project.projectRoot, "lib", "bloc"))) {
-    targetDir = path5.join(project.projectRoot, "lib", "bloc");
-    clack.log.info(`Target: ${chalk2.cyan("lib/bloc/")}`);
+  } else if (fs8.existsSync(path8.join(project.projectRoot, "lib", "bloc"))) {
+    targetDir = path8.join(project.projectRoot, "lib", "bloc");
+    clack.log.info(`Target: ${chalk4.cyan("lib/bloc/")}`);
   } else {
-    clack.note("No lib/features/ directory found. Provide a target path manually.", "Info");
+    clack.note(
+      "No lib/features/ directory found. Provide a target path manually.",
+      "Info"
+    );
     const customPath = await clack.text({
       message: "Target directory path",
       placeholder: "lib/features/auth",
@@ -365,7 +1237,7 @@ async function interactiveMode() {
       clack.cancel("Cancelled");
       return;
     }
-    targetDir = path5.resolve(customPath);
+    targetDir = path8.resolve(customPath);
   }
   const defaultRun = project.hasBuildRunner;
   const runBuildRunner2 = await clack.confirm({
@@ -384,10 +1256,180 @@ async function interactiveMode() {
       buildRunner: runBuildRunner2
     });
     genSpinner.stop("BLoC generated");
-    clack.outro(chalk2.green("Done!"));
+    clack.outro(chalk4.green("Done!"));
   } catch (error) {
     genSpinner.stop("Failed");
-    clack.outro(chalk2.red(`Error: ${error}`));
+    clack.outro(chalk4.red(`Error: ${error}`));
+  }
+}
+async function widgetFlow(project) {
+  const ds = detectDesignSystem(project.projectRoot);
+  if (!ds) {
+    clack.outro(
+      chalk4.red(
+        "No design system detected. Ensure wl_design_system/ directory exists."
+      )
+    );
+    return;
+  }
+  clack.log.info(
+    `Design system: ${chalk4.cyan(path8.relative(project.projectRoot, ds.componentsDir))}`
+  );
+  const name = await clack.text({
+    message: "Widget name (snake_case, without wl_ prefix)",
+    placeholder: "e.g. toggle, badge, snackbar",
+    validate: (value) => {
+      if (!value.trim()) return "Name is required";
+      const clean = value.startsWith("wl_") ? value.slice(3) : value;
+      if (!SNAKE_CASE_REGEX4.test(clean))
+        return "Must be snake_case (lowercase, digits, underscores)";
+    }
+  });
+  if (clack.isCancel(name)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  const allTiers = VALID_TIERS.map((t) => ({
+    value: t,
+    label: tierLabel(t)
+  }));
+  const selectedTier = await clack.select({
+    message: "Select tier",
+    options: allTiers
+  });
+  if (clack.isCancel(selectedTier)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  const tier = selectedTier;
+  const patterns = getValidPatterns(tier);
+  let selectedPattern = getDefaultPattern(tier);
+  if (patterns.length > 1) {
+    const patternChoice = await clack.select({
+      message: "Select pattern",
+      options: patterns.map((p) => ({
+        value: p,
+        label: patternLabel(p)
+      }))
+    });
+    if (clack.isCancel(patternChoice)) {
+      clack.cancel("Cancelled");
+      return;
+    }
+    selectedPattern = patternChoice;
+  }
+  const genSpinner = clack.spinner();
+  genSpinner.start("Generating widget files...");
+  try {
+    await createWidget(name, tier, {
+      projectRoot: project.projectRoot,
+      pattern: selectedPattern
+    });
+    genSpinner.stop("Widget generated");
+    clack.outro(chalk4.green("Done!"));
+  } catch (error) {
+    genSpinner.stop("Failed");
+    clack.outro(chalk4.red(`Error: ${error}`));
+  }
+}
+async function useCaseFlow(project) {
+  const ds = detectDesignSystem(project.projectRoot);
+  if (!ds) {
+    clack.outro(
+      chalk4.red(
+        "No design system detected. Ensure wl_design_system/ directory exists."
+      )
+    );
+    return;
+  }
+  if (!ds.widgetbookDir) {
+    clack.outro(
+      chalk4.red(
+        "No widgetbook package detected. Ensure apps/widgetbook/ exists."
+      )
+    );
+    return;
+  }
+  const name = await clack.text({
+    message: "Widget name for use-case (snake_case, without wl_ prefix)",
+    placeholder: "e.g. toggle, badge",
+    validate: (value) => {
+      if (!value.trim()) return "Name is required";
+      const clean = value.startsWith("wl_") ? value.slice(3) : value;
+      if (!SNAKE_CASE_REGEX4.test(clean))
+        return "Must be snake_case (lowercase, digits, underscores)";
+    }
+  });
+  if (clack.isCancel(name)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  const allTiers = VALID_TIERS.map((t) => ({
+    value: t,
+    label: tierLabel(t)
+  }));
+  const selectedTier = await clack.select({
+    message: "Select widget tier",
+    options: allTiers
+  });
+  if (clack.isCancel(selectedTier)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  const tier = selectedTier;
+  const runBuildRunner2 = await clack.confirm({
+    message: "Run build_runner after generation?",
+    initialValue: true
+  });
+  if (clack.isCancel(runBuildRunner2)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  const genSpinner = clack.spinner();
+  genSpinner.start("Generating use-case file...");
+  try {
+    await createUseCase(name, tier, {
+      projectRoot: project.projectRoot,
+      buildRunner: runBuildRunner2
+    });
+    genSpinner.stop("Use-case generated");
+    clack.outro(chalk4.green("Done!"));
+  } catch (error) {
+    genSpinner.stop("Failed");
+    clack.outro(chalk4.red(`Error: ${error}`));
+  }
+}
+async function interactiveMode() {
+  clack.intro(chalk4.bgCyan(chalk4.black(" wlmaker ")));
+  const createType = await clack.select({
+    message: "What do you want to create?",
+    options: [
+      { value: "bloc", label: "BLoC", hint: "State management" },
+      { value: "widget", label: "Widget", hint: "Design system component" },
+      {
+        value: "usecase",
+        label: "Widgetbook Use-Case",
+        hint: "Component showcase"
+      }
+    ]
+  });
+  if (clack.isCancel(createType)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  const type = createType;
+  const project = await resolveProject();
+  if (!project) return;
+  switch (type) {
+    case "bloc":
+      await blocFlow(project);
+      break;
+    case "widget":
+      await widgetFlow(project);
+      break;
+    case "usecase":
+      await useCaseFlow(project);
+      break;
   }
 }
 
@@ -395,19 +1437,49 @@ async function interactiveMode() {
 var require2 = createRequire(import.meta.url);
 var pkg = require2("../package.json");
 var program = new Command();
-program.name("wlmaker").description("Create Flutter BLoCs with Freezed sealed classes from the terminal").version(pkg.version);
-program.command("bloc").description("Create a new BLoC with Freezed sealed classes").argument("[name]", "BLoC name in snake_case (e.g. user_login)").option("-d, --dir <path>", "target directory", process.cwd()).option("--no-build-runner", "skip build_runner execution").action(async (name, options) => {
-  if (!name) {
-    await interactiveMode();
-    return;
+program.name("wlmaker").description(
+  "Create Flutter BLoCs, Widgets, and Widgetbook Use-Cases from the terminal"
+).version(pkg.version);
+program.command("bloc").description("Create a new BLoC with Freezed sealed classes").argument("[name]", "BLoC name in snake_case (e.g. user_login)").option("-d, --dir <path>", "target directory", process.cwd()).option("--no-build-runner", "skip build_runner execution").action(
+  async (name, options) => {
+    if (!name) {
+      await interactiveMode();
+      return;
+    }
+    try {
+      await createBloc(name, options);
+    } catch (error) {
+      console.error(chalk5.red(`Error: ${error}`));
+      process.exit(1);
+    }
   }
-  try {
-    await createBloc(name, options);
-  } catch (error) {
-    console.error(chalk3.red(`Error: ${error}`));
-    process.exit(1);
+);
+program.command("widget").description("Create a new widget in the design system").argument("<name>", "Widget name in snake_case (e.g. toggle)").requiredOption("-t, --tier <tier>", "tier: atom, molecule, organism, template").option("-p, --pattern <pattern>", "pattern (default depends on tier)").option("-d, --dir <path>", "project root directory", process.cwd()).action(
+  async (name, options) => {
+    try {
+      await createWidget(name, options.tier, {
+        projectRoot: options.dir,
+        pattern: options.pattern
+      });
+    } catch (error) {
+      console.error(chalk5.red(`Error: ${error}`));
+      process.exit(1);
+    }
   }
-});
+);
+program.command("usecase").description("Create a Widgetbook use-case for an existing widget").argument("<name>", "Widget name in snake_case (e.g. toggle)").requiredOption("-t, --tier <tier>", "tier: atom, molecule, organism, template").option("-d, --dir <path>", "project root directory", process.cwd()).option("--no-build-runner", "skip build_runner execution").action(
+  async (name, options) => {
+    try {
+      await createUseCase(name, options.tier, {
+        projectRoot: options.dir,
+        buildRunner: options.buildRunner
+      });
+    } catch (error) {
+      console.error(chalk5.red(`Error: ${error}`));
+      process.exit(1);
+    }
+  }
+);
 program.action(async () => {
   await interactiveMode();
 });

package/package.json

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