wlmaker 1.6.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-554WKK3Z.mjs

@@ -0,0 +1,85 @@
+#!/usr/bin/env node
+import {
+  injectMethod
+} from "./chunk-7KUDXB2F.mjs";
+import {
+  blocRegistrationSnippet,
+  collaborativeBlocEventTemplate,
+  collaborativeBlocStateTemplate,
+  collaborativeBlocTemplate
+} from "./chunk-ELYQ3PL5.mjs";
+
+// src/generators/collaborative/bloc/generator.ts
+import * as fs from "fs";
+import * as path from "path";
+import chalk from "chalk";
+import { pascalCase } from "change-case";
+var SNAKE_CASE_REGEX = /^[a-z][a-z0-9_]*$/;
+async function createCollaborativeBloc(options) {
+  const { featurePath, blocName } = options;
+  const pascal = pascalCase(blocName);
+  if (!SNAKE_CASE_REGEX.test(blocName)) {
+    throw new Error(
+      "BLoC name must be snake_case (lowercase letters, digits, underscores)."
+    );
+  }
+  const lib = path.join(featurePath, "lib");
+  const blocDir = path.join(lib, "presentation", "bloc");
+  if (!fs.existsSync(blocDir)) {
+    throw new Error(
+      `Not a collaborative feature structure. Missing: ${blocDir}`
+    );
+  }
+  const blocFile = path.join(blocDir, `${blocName}_bloc.dart`);
+  if (fs.existsSync(blocFile)) {
+    throw new Error(`BLoC "${blocName}" already exists at ${blocFile}`);
+  }
+  fs.writeFileSync(
+    blocFile,
+    collaborativeBlocTemplate(blocName, pascal)
+  );
+  console.log(chalk.green(`  BLoC created: ${blocFile}`));
+  fs.writeFileSync(
+    path.join(blocDir, `${blocName}_event.dart`),
+    collaborativeBlocEventTemplate(blocName, pascal)
+  );
+  fs.writeFileSync(
+    path.join(blocDir, `${blocName}_state.dart`),
+    collaborativeBlocStateTemplate(blocName, pascal)
+  );
+  console.log(chalk.green(`  Event + State files created`));
+  const barrelPath = path.join(blocDir, "bloc.dart");
+  const exportLine = `export '${blocName}_bloc.dart';`;
+  if (fs.existsSync(barrelPath)) {
+    const content = fs.readFileSync(barrelPath, "utf8");
+    if (!content.includes(exportLine)) {
+      fs.writeFileSync(barrelPath, content.trimEnd() + "\n" + exportLine + "\n");
+    }
+  } else {
+    fs.writeFileSync(barrelPath, exportLine + "\n");
+  }
+  const featureName = path.basename(featurePath);
+  const diDir = path.join(lib, "di");
+  const blocsModulePath = path.join(diDir, "blocs_module.dart");
+  if (fs.existsSync(blocsModulePath)) {
+    const snippet = blocRegistrationSnippet(blocName, pascal);
+    const importLine = `import 'package:${featureName}/presentation/bloc/${blocName}_bloc.dart';`;
+    const content = fs.readFileSync(blocsModulePath, "utf8");
+    if (!content.includes(importLine)) {
+      const importRegex = /^import\s+[^;]+;/gm;
+      const imports = [...content.matchAll(importRegex)];
+      if (imports.length > 0) {
+        const lastImport = imports[imports.length - 1];
+        const insertPos = lastImport.index + lastImport[0].length;
+        const newContent = content.slice(0, insertPos) + "\n" + importLine + content.slice(insertPos);
+        fs.writeFileSync(blocsModulePath, newContent);
+      }
+    }
+    injectMethod(blocsModulePath, "BlocsModule", snippet);
+    console.log(chalk.green("  Registered in BlocsModule"));
+  }
+}
+
+export {
+  createCollaborativeBloc
+};

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-7KUDXB2F.mjs

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+
+// src/dart/injector.ts
+import * as fs from "fs";
+function injectMethod(filePath, className, methodCode, dedupKey) {
+  const content = fs.readFileSync(filePath, "utf8");
+  const dedup = dedupKey ?? findSignature(methodCode);
+  if (dedup && content.includes(dedup)) {
+    return;
+  }
+  const classRegex = new RegExp(`class\\s+${className}\\s*[^{]*\\{`);
+  const classMatch = content.match(classRegex);
+  if (!classMatch) {
+    throw new Error(`Class "${className}" not found in ${filePath}`);
+  }
+  const classStart = content.indexOf(classMatch[0]);
+  let braceCount = 0;
+  let classEnd = -1;
+  let foundOpen = false;
+  for (let i = classStart; i < content.length; i++) {
+    if (content[i] === "{") {
+      braceCount++;
+      foundOpen = true;
+    } else if (content[i] === "}") {
+      braceCount--;
+      if (foundOpen && braceCount === 0) {
+        classEnd = i;
+        break;
+      }
+    }
+  }
+  if (classEnd === -1) {
+    throw new Error(`Could not find closing brace for class "${className}" in ${filePath}`);
+  }
+  const indentedMethod = methodCode.split("\n").map((line) => line.trim() ? `  ${line}` : "").join("\n");
+  const newContent = content.slice(0, classEnd) + "\n" + indentedMethod + "\n" + content.slice(classEnd);
+  fs.writeFileSync(filePath, newContent);
+}
+function injectImport(filePath, importLine) {
+  const content = fs.readFileSync(filePath, "utf8");
+  if (content.includes(importLine.trim())) {
+    return;
+  }
+  const importRegex = /^import\s+[^;]+;/gm;
+  const imports = [...content.matchAll(importRegex)];
+  if (imports.length > 0) {
+    const lastImport = imports[imports.length - 1];
+    const insertPos = lastImport.index + lastImport[0].length;
+    const newContent = content.slice(0, insertPos) + "\n" + importLine + content.slice(insertPos);
+    fs.writeFileSync(filePath, newContent);
+  } else {
+    fs.writeFileSync(filePath, importLine + "\n\n" + content);
+  }
+}
+function injectExport(filePath, exportLine) {
+  let content = "";
+  if (fs.existsSync(filePath)) {
+    content = fs.readFileSync(filePath, "utf8");
+  }
+  if (content.includes(exportLine)) {
+    return;
+  }
+  const lines = content.split("\n").filter((l) => l.trim().length > 0);
+  lines.push(exportLine);
+  lines.sort();
+  fs.writeFileSync(filePath, lines.join("\n") + "\n");
+}
+function findSignature(methodCode) {
+  const lines = methodCode.trim().split("\n");
+  for (const line of lines) {
+    const stripped = line.trim();
+    if (stripped && !stripped.startsWith("@")) {
+      return stripped;
+    }
+  }
+  return null;
+}
+
+export {
+  injectMethod,
+  injectImport,
+  injectExport
+};