wlmaker 1.0.0 → 1.0.1

package/dist/cli.mjs

@@ -2,6 +2,7 @@
 
 // src/cli.ts
 import { Command } from "commander";
+import chalk3 from "chalk";
 
 // src/core/create-bloc.ts
 import * as fs3 from "fs";
@@ -90,17 +91,17 @@ function hasBuildRunner(projectRoot) {
   return /build_runner/.test(pubspec);
 }
 function runBuildRunner(projectRoot) {
-  return new Promise((resolve2) => {
+  return new Promise((resolve3) => {
     const child = spawn(
       "dart",
       ["run", "build_runner", "build", "--delete-conflicting-outputs"],
       { cwd: projectRoot, stdio: "inherit" }
     );
     child.on("close", (code) => {
-      resolve2();
+      resolve3();
     });
     child.on("error", () => {
-      resolve2();
+      resolve3();
     });
   });
 }
@@ -110,16 +111,13 @@ var SNAKE_CASE_REGEX = /^[a-z][a-z0-9_]*$/;
 async function createBloc(name, options) {
   const targetDir = path3.resolve(options.dir);
   if (!name || name.trim().length === 0) {
-    console.error(chalk.red("Error: Name cannot be empty."));
-    process.exit(1);
+    throw new Error("Name cannot be empty.");
   }
   if (!SNAKE_CASE_REGEX.test(name)) {
-    console.error(chalk.red("Error: Name must be snake_case (lowercase letters, digits, underscores)."));
-    process.exit(1);
+    throw new Error("Name must be snake_case (lowercase letters, digits, underscores).");
   }
   if (fs3.existsSync(path3.join(targetDir, name))) {
-    console.error(chalk.red(`Error: Directory "${name}" already exists.`));
-    process.exit(1);
+    throw new Error(`Directory "${name}" already exists.`);
   }
   const pascal = pascalCase(name);
   const blocDir = path3.join(targetDir, name);
@@ -141,15 +139,164 @@ async function createBloc(name, options) {
       }
     }
   } catch (error) {
-    console.error(chalk.red(`Failed to create BLoC: ${error}`));
-    process.exit(1);
+    throw new Error(`Failed to create BLoC: ${error}`);
+  }
+}
+
+// src/interactive.ts
+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";
+import * as path4 from "path";
+import YAML from "yaml";
+function analyzeProject(startDir) {
+  const projectRoot = findPubspecDir2(startDir);
+  if (!projectRoot) return null;
+  const pubspecPath = path4.join(projectRoot, "pubspec.yaml");
+  const content = fs4.readFileSync(pubspecPath, "utf8");
+  const pubspec = YAML.parse(content);
+  const deps = {
+    ...pubspec?.dependencies,
+    ...pubspec?.dev_dependencies
+  };
+  const features = discoverFeatures(projectRoot);
+  return {
+    projectRoot,
+    projectName: pubspec?.name ?? path4.basename(projectRoot),
+    hasFreezed: "freezed" in deps || "freezed_annotation" in deps,
+    hasBloc: "flutter_bloc" in deps || "bloc" in deps,
+    hasBuildRunner: "build_runner" in deps,
+    features
+  };
+}
+function findPubspecDir2(startDir) {
+  let dir = startDir;
+  while (dir !== path4.dirname(dir)) {
+    if (fs4.existsSync(path4.join(dir, "pubspec.yaml"))) {
+      return dir;
+    }
+    dir = path4.dirname(dir);
+  }
+  return void 0;
+}
+function discoverFeatures(projectRoot) {
+  const featuresDir = path4.join(projectRoot, "lib", "features");
+  if (!fs4.existsSync(featuresDir)) return [];
+  return fs4.readdirSync(featuresDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
+}
+
+// src/interactive.ts
+var SNAKE_CASE_REGEX2 = /^[a-z][a-z0-9_]*$/;
+async function interactiveMode() {
+  clack.intro(chalk2.bgCyan(chalk2.black(" wlmaker ")));
+  const s = clack.spinner();
+  s.start("Analyzing Flutter project...");
+  const project = analyzeProject(process.cwd());
+  if (!project) {
+    s.stop("No Flutter project found");
+    clack.outro(chalk2.red("Could not find a pubspec.yaml in the current directory or any parent."));
+    return;
+  }
+  s.stop(`Found ${chalk2.green(project.projectName)} \u2014 ${project.features.length} feature(s) detected`);
+  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 (clack.isCancel(name)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  let targetDir;
+  if (project.features.length > 0) {
+    const feature = await clack.select({
+      message: "Select feature",
+      options: [
+        ...project.features.map((f) => ({ value: f, label: f })),
+        { value: "__custom__", label: "Custom path..." }
+      ]
+    });
+    if (clack.isCancel(feature)) {
+      clack.cancel("Cancelled");
+      return;
+    }
+    if (feature === "__custom__") {
+      const customPath = await clack.text({
+        message: "Target directory path",
+        placeholder: "lib/features/auth",
+        validate: (v) => {
+          if (!v.trim()) return "Path is required";
+        }
+      });
+      if (clack.isCancel(customPath)) {
+        clack.cancel("Cancelled");
+        return;
+      }
+      targetDir = path5.resolve(customPath);
+    } else {
+      targetDir = path5.join(project.projectRoot, "lib", "features", feature);
+    }
+  } else {
+    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",
+      validate: (v) => {
+        if (!v.trim()) return "Path is required";
+      }
+    });
+    if (clack.isCancel(customPath)) {
+      clack.cancel("Cancelled");
+      return;
+    }
+    targetDir = path5.resolve(customPath);
+  }
+  const defaultRun = project.hasBuildRunner;
+  const runBuildRunner2 = await clack.confirm({
+    message: "Run build_runner after generation?",
+    initialValue: defaultRun
+  });
+  if (clack.isCancel(runBuildRunner2)) {
+    clack.cancel("Cancelled");
+    return;
+  }
+  const genSpinner = clack.spinner();
+  genSpinner.start("Generating BLoC files...");
+  try {
+    await createBloc(name, {
+      dir: targetDir,
+      buildRunner: runBuildRunner2
+    });
+    genSpinner.stop("BLoC generated");
+    clack.outro(chalk2.green("Done!"));
+  } catch (error) {
+    genSpinner.stop("Failed");
+    clack.outro(chalk2.red(`Error: ${error}`));
   }
 }
 
 // src/cli.ts
 var program = new Command();
 program.name("wlmaker").description("Create Flutter BLoCs with Freezed sealed classes from the terminal").version("1.0.0");
-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) => {
-  await createBloc(name, options);
+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(chalk3.red(`Error: ${error}`));
+    process.exit(1);
+  }
+});
+program.action(async () => {
+  await interactiveMode();
 });
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wlmaker",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "Create Flutter BLoCs with Freezed sealed classes from the terminal",
   "keywords": [
     "flutter",
@@ -26,9 +26,11 @@
     "dev": "tsup --watch"
   },
   "dependencies": {
+    "@clack/prompts": "^1.2.0",
     "chalk": "^5.3.0",
     "change-case": "^5.4.0",
-    "commander": "^12.0.0"
+    "commander": "^12.0.0",
+    "yaml": "^2.8.3"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",