wlmaker 1.7.0 → 1.8.0

package/dist/chunk-4AOS33ZX.mjs

@@ -0,0 +1,390 @@
+#!/usr/bin/env node
+import {
+  blocsModuleTemplate,
+  collaborativeGitignore,
+  collaborativePubspec,
+  datasourcesModuleTemplate,
+  emptyBarrelTemplate,
+  featureDiTemplate,
+  mainBarrelTemplate,
+  repositoriesModuleTemplate,
+  usecasesModuleTemplate
+} from "./chunk-ELYQ3PL5.mjs";
+import {
+  resolveWorkspaceVersions
+} from "./chunk-V4S7DQDN.mjs";
+
+// src/generators/collaborative/feature/generator.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+import { execSync } from "child_process";
+import chalk3 from "chalk";
+import { pascalCase } from "change-case";
+
+// src/shared/pub-workspace.ts
+import * as fs from "fs";
+import * as path from "path";
+import YAML from "yaml";
+import chalk from "chalk";
+var WORKSPACE_MEMBER_RE = /^(\s*)-\s+(\S+)\s*$/;
+function usesPubWorkspace(monorepoRoot) {
+  const pubspecPath = path.join(monorepoRoot, "pubspec.yaml");
+  if (!fs.existsSync(pubspecPath)) return false;
+  try {
+    const pubspec = YAML.parse(fs.readFileSync(pubspecPath, "utf8"));
+    return Array.isArray(pubspec?.workspace);
+  } catch {
+    return false;
+  }
+}
+function addWorkspaceMember(monorepoRoot, memberPath) {
+  const pubspecPath = path.join(monorepoRoot, "pubspec.yaml");
+  if (!fs.existsSync(pubspecPath)) {
+    console.log(chalk.yellow("  No root pubspec.yaml found, skipping workspace registration"));
+    return false;
+  }
+  const content = fs.readFileSync(pubspecPath, "utf8");
+  const lines = content.split("\n");
+  const workspaceIdx = lines.findIndex((l) => /^workspace:\s*$/.test(l));
+  if (workspaceIdx === -1) {
+    console.log(
+      chalk.yellow("  No workspace: list in root pubspec.yaml (legacy Melos), skipping")
+    );
+    return false;
+  }
+  let blockStart = workspaceIdx + 1;
+  let blockEnd = blockStart;
+  while (blockEnd < lines.length) {
+    const line = lines[blockEnd];
+    if (line.trim() === "") break;
+    if (!WORKSPACE_MEMBER_RE.test(line)) break;
+    blockEnd++;
+  }
+  for (let i = blockStart; i < blockEnd; i++) {
+    const match = lines[i].match(WORKSPACE_MEMBER_RE);
+    if (match?.[2] === memberPath) {
+      console.log(chalk.yellow(`  Already in workspace: ${memberPath}`));
+      return false;
+    }
+  }
+  let insertAt = blockEnd;
+  for (let i = blockStart; i < blockEnd; i++) {
+    const match = lines[i].match(WORKSPACE_MEMBER_RE);
+    if (match && match[2].localeCompare(memberPath) > 0) {
+      insertAt = i;
+      break;
+    }
+  }
+  lines.splice(insertAt, 0, `  - ${memberPath}`);
+  fs.writeFileSync(pubspecPath, lines.join("\n"));
+  console.log(chalk.green(`  Added ${memberPath} to root pubspec.yaml workspace`));
+  return true;
+}
+function removeMemberPubspecLock(memberDir) {
+  const lockPath = path.join(memberDir, "pubspec.lock");
+  if (fs.existsSync(lockPath)) {
+    fs.unlinkSync(lockPath);
+    console.log(chalk.green("  Removed member pubspec.lock (workspace uses root lock)"));
+  }
+}
+
+// src/shared/ide-workspace.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import chalk2 from "chalk";
+function findWorkspaceFile(monorepoRoot) {
+  const files = fs2.readdirSync(monorepoRoot);
+  return files.find((f) => f.endsWith(".code-workspace")) ?? null;
+}
+function updateCodeWorkspaceFolder(monorepoRoot, folderPath, displayName) {
+  const wsFileName = findWorkspaceFile(monorepoRoot);
+  if (!wsFileName) {
+    console.log(chalk2.yellow("  No .code-workspace file found, skipping"));
+    return;
+  }
+  const wsPath = path2.join(monorepoRoot, wsFileName);
+  const content = fs2.readFileSync(wsPath, "utf8");
+  if (content.includes(`"path": "${folderPath}"`)) {
+    console.log(chalk2.yellow(`  Already in ${wsFileName}`));
+    return;
+  }
+  const label = displayName ?? path2.basename(folderPath);
+  const folderName = `\u{1F4E6} ${label}`;
+  const newBlock = `    {
+      "name": "${folderName}",
+      "path": "${folderPath}"
+    },`;
+  const lines = content.split("\n");
+  const foldersLineIdx = lines.findIndex((l) => l.includes('"folders"'));
+  if (foldersLineIdx === -1) {
+    console.log(chalk2.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(chalk2.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(chalk2.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(chalk2.yellow("  No widgetbook entry found in workspace, skipping"));
+    return;
+  }
+  lines.splice(widgetbookBlockStart, 0, newBlock);
+  fs2.writeFileSync(wsPath, lines.join("\n"));
+  console.log(chalk2.green(`  Updated ${wsFileName}`));
+}
+function updateHelixWorkspaceFolder(monorepoRoot, folderPath) {
+  const helixPath = path2.join(monorepoRoot, ".helix", "languages.toml");
+  if (!fs2.existsSync(helixPath)) {
+    console.log(chalk2.yellow("  No .helix/languages.toml found, skipping"));
+    return;
+  }
+  const content = fs2.readFileSync(helixPath, "utf8");
+  const entry = `{ path = "${folderPath}" }`;
+  if (content.includes(entry)) {
+    console.log(chalk2.yellow("  Already in .helix/languages.toml"));
+    return;
+  }
+  const workspaceLineRegex = /^\s*\{\s*path\s*=\s*"(?:apps|packages)\//;
+  const lines = content.split("\n");
+  let lastPackageLineIdx = -1;
+  for (let i = 0; i < lines.length; i++) {
+    if (workspaceLineRegex.test(lines[i])) {
+      lastPackageLineIdx = i;
+    }
+  }
+  const sortKey = folderPath.replace(/^(apps|packages)\//, "");
+  if (lastPackageLineIdx === -1) {
+    const closingBracketIdx = lines.findIndex((l) => l.trim() === "]");
+    if (closingBracketIdx === -1) {
+      console.log(chalk2.yellow("  Could not parse .helix/languages.toml"));
+      return;
+    }
+    lines.splice(closingBracketIdx, 0, `  { path = "${folderPath}" },`);
+  } else {
+    const allEntries = [];
+    for (let i = 0; i < lines.length; i++) {
+      const m = lines[i].match(/^\s*\{\s*path\s*=\s*"(?:apps|packages)\/([^"]+)"\s*\}/);
+      if (m) {
+        allEntries.push({ lineIdx: i, entry: m[1] });
+      }
+    }
+    allEntries.push({ lineIdx: -1, entry: sortKey });
+    allEntries.sort((a, b) => a.entry.localeCompare(b.entry));
+    const insertIdx = allEntries.findIndex((e) => e.entry === sortKey);
+    let targetLine;
+    if (insertIdx === 0) {
+      const firstLine = lines.findIndex((l) => workspaceLineRegex.test(l));
+      targetLine = firstLine;
+    } else {
+      const prevEntry = allEntries[insertIdx - 1];
+      targetLine = prevEntry.lineIdx + 1;
+    }
+    lines.splice(targetLine, 0, `  { path = "${folderPath}" },`);
+  }
+  fs2.writeFileSync(helixPath, lines.join("\n"));
+  console.log(chalk2.green("  Updated .helix/languages.toml"));
+}
+
+// src/generators/collaborative/feature/generator.ts
+var SNAKE_CASE_REGEX = /^[a-z][a-z0-9_]*$/;
+async function createCollaborativeFeature(options) {
+  const { monorepoRoot, featureName } = options;
+  const pascal = pascalCase(featureName);
+  const description = options.description ?? `${pascal} collaborative feature`;
+  if (!SNAKE_CASE_REGEX.test(featureName)) {
+    throw new Error(
+      "Feature name must be snake_case (lowercase letters, digits, underscores)."
+    );
+  }
+  const collaborativeDir = path3.join(monorepoRoot, "packages", "collaborative");
+  if (!fs3.existsSync(collaborativeDir)) {
+    fs3.mkdirSync(collaborativeDir, { recursive: true });
+  }
+  const pkgDir = path3.join(collaborativeDir, featureName);
+  if (fs3.existsSync(pkgDir)) {
+    throw new Error(`packages/collaborative/${featureName} already exists`);
+  }
+  console.log(
+    chalk3.bold(`
+Creating collaborative feature: ${chalk3.cyan(featureName)}
+`)
+  );
+  console.log(chalk3.cyan(" -> Running flutter create..."));
+  execSync(
+    `flutter create --template=package packages/collaborative/${featureName}`,
+    { cwd: monorepoRoot, stdio: "pipe" }
+  );
+  const autoTestFile = path3.join(pkgDir, "test", `${featureName}_test.dart`);
+  if (fs3.existsSync(autoTestFile)) {
+    fs3.unlinkSync(autoTestFile);
+  }
+  removeMemberPubspecLock(pkgDir);
+  console.log(chalk3.cyan(" -> Generating feature structure..."));
+  const lib = path3.join(pkgDir, "lib");
+  const dirs = [
+    path3.join(lib, "data", "api", "bff"),
+    path3.join(lib, "data", "datasources"),
+    path3.join(lib, "data", "models"),
+    path3.join(lib, "data", "repositories"),
+    path3.join(lib, "domain", "entities"),
+    path3.join(lib, "domain", "repositories"),
+    path3.join(lib, "domain", "usecases"),
+    path3.join(lib, "presentation", "bloc"),
+    path3.join(lib, "presentation", "pages", "views"),
+    path3.join(lib, "di")
+  ];
+  for (const dir of dirs) {
+    fs3.mkdirSync(dir, { recursive: true });
+  }
+  const pubWorkspace = usesPubWorkspace(monorepoRoot);
+  const workspaceVersions = resolveWorkspaceVersions(monorepoRoot);
+  fs3.writeFileSync(
+    path3.join(pkgDir, "pubspec.yaml"),
+    collaborativePubspec(featureName, description, workspaceVersions, pubWorkspace)
+  );
+  fs3.writeFileSync(
+    path3.join(pkgDir, ".gitignore"),
+    collaborativeGitignore()
+  );
+  const diDir = path3.join(lib, "di");
+  fs3.writeFileSync(
+    path3.join(diDir, `${featureName}_di.dart`),
+    featureDiTemplate(featureName)
+  );
+  fs3.writeFileSync(
+    path3.join(diDir, "blocs_module.dart"),
+    blocsModuleTemplate(featureName)
+  );
+  fs3.writeFileSync(
+    path3.join(diDir, "datasources_module.dart"),
+    datasourcesModuleTemplate(featureName)
+  );
+  fs3.writeFileSync(
+    path3.join(diDir, "repositories_module.dart"),
+    repositoriesModuleTemplate(featureName)
+  );
+  fs3.writeFileSync(
+    path3.join(diDir, "usecases_module.dart"),
+    usecasesModuleTemplate(featureName)
+  );
+  const barrelPaths = [
+    path3.join(lib, "data", "api", "bff", "bff.dart"),
+    path3.join(lib, "data", "datasources", "datasources.dart"),
+    path3.join(lib, "data", "models", "models.dart"),
+    path3.join(lib, "data", "repositories", "repositories.dart"),
+    path3.join(lib, "domain", "entities", "entities.dart"),
+    path3.join(lib, "domain", "repositories", "repositories.dart"),
+    path3.join(lib, "domain", "usecases", "usecases.dart"),
+    path3.join(lib, "presentation", "bloc", "bloc.dart"),
+    path3.join(lib, "presentation", "pages", "views", "views.dart"),
+    path3.join(lib, "presentation", "pages", "pages.dart")
+  ];
+  for (const barrelPath of barrelPaths) {
+    fs3.writeFileSync(barrelPath, emptyBarrelTemplate());
+  }
+  fs3.writeFileSync(
+    path3.join(lib, `${featureName}.dart`),
+    mainBarrelTemplate(featureName)
+  );
+  console.log(chalk3.cyan(" -> Updating workspace configuration..."));
+  if (pubWorkspace) {
+    addWorkspaceMember(monorepoRoot, `packages/collaborative/${featureName}`);
+  }
+  updateCodeWorkspaceFolder(
+    monorepoRoot,
+    `packages/collaborative/${featureName}`,
+    `collaborative/${featureName}`
+  );
+  updateHelixWorkspaceFolder(
+    monorepoRoot,
+    `packages/collaborative/${featureName}`
+  );
+  if (options.runBootstrap !== false) {
+    console.log(chalk3.cyan(" -> Running melos bootstrap..."));
+    try {
+      execSync("melos bootstrap", { cwd: monorepoRoot, stdio: "pipe" });
+      console.log(chalk3.green("  melos bootstrap completed"));
+    } catch {
+      console.log(
+        chalk3.yellow("  melos bootstrap failed (you may need to run it manually)")
+      );
+    }
+  }
+  console.log(
+    chalk3.green(`
+Feature "${featureName}" created successfully!`)
+  );
+  console.log(chalk3.gray(`  ${pkgDir}`));
+  console.log(chalk3.gray(`
+  Next steps:`));
+  console.log(chalk3.gray(`    wlmaker collaborative endpoint ...`));
+  console.log(chalk3.gray(`    wlmaker collaborative bloc ...`));
+  console.log(chalk3.gray(`    wlmaker collaborative page ...`));
+}
+
+export {
+  usesPubWorkspace,
+  addWorkspaceMember,
+  removeMemberPubspecLock,
+  updateCodeWorkspaceFolder,
+  updateHelixWorkspaceFolder,
+  createCollaborativeFeature
+};

package/dist/{chunk-LHUDYCA5.mjs → chunk-554WKK3Z.mjs}

@@ -7,7 +7,7 @@ import {
   collaborativeBlocEventTemplate,
   collaborativeBlocStateTemplate,
   collaborativeBlocTemplate
-} from "./chunk-OTFDN3HG.mjs";
+} from "./chunk-ELYQ3PL5.mjs";
 
 // src/generators/collaborative/bloc/generator.ts
 import * as fs from "fs";

package/dist/chunk-6JXSEAVX.mjs

@@ -0,0 +1,49 @@
+#!/usr/bin/env node
+
+// src/analyzer/region-parser.ts
+function parseRegions(code) {
+  const regions = {};
+  const errors = [];
+  const openStack = [];
+  const lines = code.split("\n");
+  const regionStart = /\/\/\s*#?\s*region\s+(.+)/i;
+  const regionEnd = /\/\/\s*#?\s*endregion/i;
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNum = i + 1;
+    const startMatch = line.match(regionStart);
+    if (startMatch) {
+      const name = startMatch[1].trim();
+      if (openStack.length > 0) {
+        errors.push(
+          `Line ${lineNum}: nested region "${name}" inside "${openStack[openStack.length - 1].name}" \u2014 regions cannot be nested`
+        );
+        continue;
+      }
+      openStack.push({ name, startLine: lineNum });
+      continue;
+    }
+    const endMatch = line.match(regionEnd);
+    if (endMatch) {
+      if (openStack.length === 0) {
+        errors.push(`Line ${lineNum}: //#endregion without matching //#region`);
+        continue;
+      }
+      const opened = openStack.pop();
+      regions[opened.name] = {
+        name: opened.name,
+        content: lines.slice(opened.startLine, i).join("\n").trim(),
+        startLine: opened.startLine,
+        endLine: lineNum
+      };
+    }
+  }
+  for (const opened of openStack) {
+    errors.push(`Line ${opened.startLine}: unclosed region "${opened.name}" \u2014 missing //#endregion`);
+  }
+  return { regions, errors };
+}
+
+export {
+  parseRegions
+};

package/dist/{chunk-OTFDN3HG.mjs → chunk-ELYQ3PL5.mjs}

@@ -2,6 +2,7 @@
 
 // src/generators/collaborative/collaborative-templates.ts
 import { camelCase, pascalCase } from "change-case";
+var WORKSPACE_PACKAGES = /* @__PURE__ */ new Set(["app_base", "core", "design_system", "localization"]);
 var COLLABORATIVE_DEPS = [
   "app_base",
   "dio",
@@ -26,7 +27,45 @@ var COLLABORATIVE_OVERRIDE_EXCLUDE = /* @__PURE__ */ new Set([
   "build_runner",
   "source_gen"
 ]);
-function collaborativePubspec(featureName, description, versions) {
+function collaborativePubspec(featureName, description, versions, pubWorkspace = false) {
+  if (pubWorkspace) {
+    const depLines2 = [
+      "  flutter:",
+      "    sdk: flutter"
+    ];
+    for (const dep of COLLABORATIVE_DEPS) {
+      depLines2.push(
+        WORKSPACE_PACKAGES.has(dep) ? `  ${dep}:` : `  ${dep}: any`
+      );
+    }
+    const devDepLines2 = [
+      "  flutter_test:",
+      "    sdk: flutter"
+    ];
+    for (const dep of COLLABORATIVE_DEV_DEPS) {
+      devDepLines2.push(`  ${dep}: any`);
+    }
+    return `name: ${featureName}
+description: "${description}"
+version: 0.0.1
+publish_to: none
+
+environment:
+  sdk: ^3.8.1
+  flutter: ">=1.17.0"
+
+resolution: workspace
+
+dependencies:
+${depLines2.join("\n")}
+
+dev_dependencies:
+${devDepLines2.join("\n")}
+
+flutter:
+  uses-material-design: true
+`;
+  }
   const depLines = ["  app_base:"];
   for (const dep of COLLABORATIVE_DEPS) {
     if (dep === "app_base") continue;

package/dist/{chunk-BVPCRMD4.mjs → chunk-P7W5YVTZ.mjs}

@@ -5,7 +5,7 @@ import {
 import {
   collaborativePageTemplate,
   collaborativeViewTemplate
-} from "./chunk-OTFDN3HG.mjs";
+} from "./chunk-ELYQ3PL5.mjs";
 
 // src/generators/collaborative/page/generator.ts
 import * as fs from "fs";

package/dist/{chunk-KBIXWYFD.mjs → chunk-V4S7DQDN.mjs}

@@ -39,10 +39,23 @@ function discoverFeatures(projectRoot) {
   if (!fs.existsSync(featuresDir)) return [];
   return fs.readdirSync(featuresDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name).sort();
 }
+function isMonorepoRoot(dir) {
+  if (fs.existsSync(path.join(dir, "melos.yaml"))) {
+    return true;
+  }
+  const pubspecPath = path.join(dir, "pubspec.yaml");
+  if (!fs.existsSync(pubspecPath)) return false;
+  try {
+    const pubspec = YAML.parse(fs.readFileSync(pubspecPath, "utf8"));
+    return Boolean(pubspec?.workspace) || Boolean(pubspec?.melos);
+  } catch {
+    return false;
+  }
+}
 function findMonorepoRoot(startDir) {
   let dir = startDir;
   while (dir !== path.dirname(dir)) {
-    if (fs.existsSync(path.join(dir, "melos.yaml"))) {
+    if (isMonorepoRoot(dir)) {
       return dir;
     }
     dir = path.dirname(dir);
@@ -156,6 +169,7 @@ function discoverProjects(searchDir, maxDepth = 2) {
 
 export {
   analyzeProject,
+  isMonorepoRoot,
   findMonorepoRoot,
   discoverPackages,
   discoverCollaborativeFeatures,