wlmaker 1.0.0 → 1.0.2

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,270 @@ 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 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";
+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();
+}
+function findMonorepoRoot(startDir) {
+  let dir = startDir;
+  while (dir !== path4.dirname(dir)) {
+    if (fs4.existsSync(path4.join(dir, "melos.yaml"))) {
+      return dir;
+    }
+    dir = path4.dirname(dir);
+  }
+  return void 0;
+}
+function discoverPackages(monorepoRoot) {
+  const packageDirs = ["packages", "packages/features"];
+  const projects = [];
+  for (const base of packageDirs) {
+    const baseDir = path4.join(monorepoRoot, base);
+    if (!fs4.existsSync(baseDir)) continue;
+    const entries = fs4.readdirSync(baseDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const candidate = path4.join(baseDir, entry.name);
+      if (!fs4.existsSync(path4.join(candidate, "pubspec.yaml"))) continue;
+      const project = analyzeProject(candidate);
+      if (project && (project.hasFreezed || project.hasBloc)) {
+        projects.push(project);
+      }
+    }
+  }
+  return projects.sort((a, b) => a.projectName.localeCompare(b.projectName));
+}
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".dart_tool",
+  "build",
+  ".git",
+  ".idea",
+  ".fvm",
+  "coverage"
+]);
+function discoverProjects(searchDir, maxDepth = 2) {
+  const projects = [];
+  function walk(dir, depth) {
+    if (depth > maxDepth) return;
+    const project = analyzeProject(dir);
+    if (project && (project.hasFreezed || project.hasBloc)) {
+      projects.push(project);
+      return;
+    }
+    if (!fs4.existsSync(dir)) return;
+    let entries;
+    try {
+      entries = fs4.readdirSync(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (!entry.isDirectory() || IGNORED_DIRS.has(entry.name)) continue;
+      walk(path4.join(dir, entry.name), depth + 1);
+    }
+  }
+  walk(searchDir, 0);
+  return projects.sort((a, b) => a.projectName.localeCompare(b.projectName));
+}
+
+// src/interactive.ts
+var SNAKE_CASE_REGEX2 = /^[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)}`);
+    return cwdProject;
+  }
+  s.message("Looking for Melos monorepo...");
+  const monorepoRoot = findMonorepoRoot(process.cwd());
+  if (monorepoRoot) {
+    const packages = discoverPackages(monorepoRoot);
+    if (packages.length > 0) {
+      s.stop(`Found monorepo with ${packages.length} feature package(s)`);
+      return selectPackage(packages);
+    }
+  }
+  s.message("Scanning for Flutter projects...");
+  const homeDev = path5.join(os.homedir(), "Development");
+  if (fs5.existsSync(homeDev)) {
+    const projects = discoverProjects(homeDev, 2);
+    if (projects.length > 0) {
+      s.stop(`Found ${projects.length} Flutter project(s)`);
+      return selectPackage(projects);
+    }
+  }
+  s.stop("No Flutter projects found");
+  clack.outro(chalk2.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)}`);
+    return projects[0];
+  }
+  const selected = await clack.select({
+    message: "Select a package",
+    options: projects.map((p) => ({
+      value: p,
+      label: p.projectName,
+      hint: path5.relative(os.homedir(), p.projectRoot)
+    }))
+  });
+  if (clack.isCancel(selected)) {
+    clack.cancel("Cancelled");
+    return null;
+  }
+  return selected;
+}
+async function interactiveMode() {
+  clack.intro(chalk2.bgCyan(chalk2.black(" wlmaker ")));
+  const project = await resolveProject();
+  if (!project) return;
+  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.2",
   "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",