@solid-stack/mason 1.0.22 → 1.0.24

package/dist/bin.cjs

@@ -3,7 +3,7 @@
 
 var cac = require('cac');
 var p14 = require('@clack/prompts');
-var pc15 = require('picocolors');
+var pc14 = require('picocolors');
 var fs9 = require('fs');
 var path2 = require('path');
 var url = require('url');
@@ -33,7 +33,7 @@ function _interopNamespace(e) {
 }
 
 var p14__namespace = /*#__PURE__*/_interopNamespace(p14);
-var pc15__default = /*#__PURE__*/_interopDefault(pc15);
+var pc14__default = /*#__PURE__*/_interopDefault(pc14);
 var fs9__default = /*#__PURE__*/_interopDefault(fs9);
 var path2__default = /*#__PURE__*/_interopDefault(path2);
 var Handlebars__default = /*#__PURE__*/_interopDefault(Handlebars);
@@ -76,17 +76,17 @@ function writeFileSafely(absolutePath, content, options = {}) {
 function printGeneratedFiles(files, isDryRun = false) {
   console.log("");
   if (isDryRun) {
-    p14__namespace.log.warn(pc15__default.default.yellow(pc15__default.default.bold("[DRY RUN PREVIEW] No files were written to disk.")));
+    p14__namespace.log.warn(pc14__default.default.yellow(pc14__default.default.bold("[DRY RUN PREVIEW] No files were written to disk.")));
   }
   for (const f of files) {
     if (f.action === "created") {
-      p14__namespace.log.success(`${pc15__default.default.bold(f.relativePath)} ${pc15__default.default.dim("(created)")}`);
+      p14__namespace.log.success(`${pc14__default.default.bold(f.relativePath)} ${pc14__default.default.dim("(created)")}`);
     } else if (f.action === "overwritten") {
-      p14__namespace.log.warn(`${pc15__default.default.bold(f.relativePath)} ${pc15__default.default.dim("(overwritten)")}`);
+      p14__namespace.log.warn(`${pc14__default.default.bold(f.relativePath)} ${pc14__default.default.dim("(overwritten)")}`);
     } else if (f.action === "skipped") {
-      p14__namespace.log.info(`${pc15__default.default.dim(f.relativePath)} ${pc15__default.default.dim("(skipped - already exists, pass -o to overwrite)")}`);
+      p14__namespace.log.info(`${pc14__default.default.dim(f.relativePath)} ${pc14__default.default.dim("(skipped - already exists, pass -o to overwrite)")}`);
     } else {
-      p14__namespace.log.info(`${pc15__default.default.bold(f.relativePath)} ${pc15__default.default.dim("(preview)")}`);
+      p14__namespace.log.info(`${pc14__default.default.bold(f.relativePath)} ${pc14__default.default.dim("(preview)")}`);
     }
   }
 }
@@ -1773,13 +1773,13 @@ function handleCancel(result) {
 }
 function printBanner() {
   console.log("");
-  p14__namespace.intro(pc15__default.default.bgCyan(pc15__default.default.black(" @solid-stack/mason ")));
+  p14__namespace.intro(pc14__default.default.bgCyan(pc14__default.default.black(" @solid-stack/mason ")));
 }
 async function promptProperties(options = {}) {
   const properties = options.defaults ? [...options.defaults] : [];
   if (properties.length > 0) {
     const summary = properties.map((p16) => `${p16.name}: ${p16.type}${p16.optional ? "?" : ""}`).join(", ");
-    p14__namespace.log.info(pc15__default.default.dim(`Pre-configured fields: ${summary}`));
+    p14__namespace.log.info(pc14__default.default.dim(`Pre-configured fields: ${summary}`));
     const addMore = handleCancel(
       await p14__namespace.confirm({
         message: "Would you like to add custom fields/properties?",
@@ -1790,7 +1790,7 @@ async function promptProperties(options = {}) {
       return properties;
     }
   }
-  p14__namespace.log.info(pc15__default.default.cyan("Enter properties (leave name blank when finished):"));
+  p14__namespace.log.info(pc14__default.default.cyan("Enter properties (leave name blank when finished):"));
   while (true) {
     const name = handleCancel(
       await p14__namespace.text({
@@ -1838,7 +1838,7 @@ async function promptProperties(options = {}) {
       optional
     });
     p14__namespace.log.success(
-      pc15__default.default.green(`Added: ${name.trim()}${optional ? "?" : ""}: ${finalType.trim()}`)
+      pc14__default.default.green(`Added: ${name.trim()}${optional ? "?" : ""}: ${finalType.trim()}`)
     );
   }
   return properties;
@@ -2098,7 +2098,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
     }
   }
   const s = p14__namespace.spinner();
-  s.start(`Generating feature '${pc15__default.default.cyan(normalizedName)}'...`);
+  s.start(`Generating feature '${pc14__default.default.cyan(normalizedName)}'...`);
   const options = {
     name: normalizedName,
     projectRoot,
@@ -2145,7 +2145,7 @@ async function runFeatureCommand(featureNameArg, flags = {}) {
   s.stop("Feature scaffolded successfully!");
   printGeneratedFiles(files, options.dryRun);
   p14__namespace.outro(
-    pc15__default.default.green(
+    pc14__default.default.green(
       `\u2713 Feature '${normalizedName}' initialized in ${path2__default.default.relative(projectRoot, targetDir)} (uncommitted, unregistered)`
     )
   );
@@ -2301,7 +2301,7 @@ async function runSharedCommand(sharedNameArg, flags = {}) {
     );
   }
   const s = p14__namespace.spinner();
-  s.start(`Generating shared module '${pc15__default.default.cyan(normalizedName)}'...`);
+  s.start(`Generating shared module '${pc14__default.default.cyan(normalizedName)}'...`);
   const files = generateShared({
     name: normalizedName,
     description,
@@ -2315,7 +2315,7 @@ async function runSharedCommand(sharedNameArg, flags = {}) {
   s.stop("Shared module generated successfully!");
   printGeneratedFiles(files, Boolean(flags.dryRun));
   p14__namespace.outro(
-    pc15__default.default.green(
+    pc14__default.default.green(
       `\u2713 Shared module '${normalizedName}' initialized in ${path2__default.default.relative(projectRoot, targetDir)} (uncommitted, unregistered)`
     )
   );
@@ -2443,7 +2443,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
     }
   }
   const s = p14__namespace.spinner();
-  s.start(`Generating use case '${pc15__default.default.cyan(ucName)}'...`);
+  s.start(`Generating use case '${pc14__default.default.cyan(ucName)}'...`);
   const options = {
     name: ucName,
     feature,
@@ -2475,7 +2475,7 @@ async function runUseCaseCommand(useCaseNameArg, flags = {}) {
   }
   s.stop("Use case generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p14__namespace.outro(pc15__default.default.green(`Use case '${ucName}' created in feature '${feature}'!`));
+  p14__namespace.outro(pc14__default.default.green(`Use case '${ucName}' created in feature '${feature}'!`));
 }
 async function runDomainCommand(domainNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2546,7 +2546,7 @@ async function runDomainCommand(domainNameArg, flags = {}) {
     });
   }
   const s = p14__namespace.spinner();
-  s.start(`Generating domain model '${pc15__default.default.cyan(entityName)}'...`);
+  s.start(`Generating domain model '${pc14__default.default.cyan(entityName)}'...`);
   const options = {
     name: entityName,
     feature,
@@ -2559,7 +2559,7 @@ async function runDomainCommand(domainNameArg, flags = {}) {
   const file = generateDomain(options);
   s.stop("Domain model generated successfully!");
   printGeneratedFiles([file], options.dryRun);
-  p14__namespace.outro(pc15__default.default.green(`Domain model '${entityName}' created in feature '${feature}'!`));
+  p14__namespace.outro(pc14__default.default.green(`Domain model '${entityName}' created in feature '${feature}'!`));
 }
 async function runInfrastructureCommand(classNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2728,7 +2728,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
     registerInProvider = !flags.noProvider;
   }
   const s = p14__namespace.spinner();
-  s.start(`Generating infrastructure class '${pc15__default.default.cyan(className)}'...`);
+  s.start(`Generating infrastructure class '${pc14__default.default.cyan(className)}'...`);
   const files = [];
   const options = {
     name: className,
@@ -2763,7 +2763,7 @@ async function runInfrastructureCommand(classNameArg, flags = {}) {
   }
   s.stop("Infrastructure class generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p14__namespace.outro(pc15__default.default.green(`Infrastructure class '${className}' created!`));
+  p14__namespace.outro(pc14__default.default.green(`Infrastructure class '${className}' created!`));
 }
 async function runInterfaceCommand(interfaceNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -2876,7 +2876,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
     }
   }
   const s = p14__namespace.spinner();
-  s.start(`Generating interface '${pc15__default.default.cyan(ifaceName)}'...`);
+  s.start(`Generating interface '${pc14__default.default.cyan(ifaceName)}'...`);
   const files = [];
   const options = {
     name: ifaceName,
@@ -2925,7 +2925,7 @@ async function runInterfaceCommand(interfaceNameArg, flags = {}) {
   }
   s.stop("Interface generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p14__namespace.outro(pc15__default.default.green(`Interface '${ifaceName}' created in feature '${feature}'!`));
+  p14__namespace.outro(pc14__default.default.green(`Interface '${ifaceName}' created in feature '${feature}'!`));
 }
 async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
   const projectRoot = findProjectRoot();
@@ -3042,7 +3042,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
     }
   }
   const s = p14__namespace.spinner();
-  s.start(`Generating HTTP handler '${pc15__default.default.cyan(className)}'...`);
+  s.start(`Generating HTTP handler '${pc14__default.default.cyan(className)}'...`);
   const options = {
     name: className,
     feature,
@@ -3060,7 +3060,7 @@ async function runHttpHandlerCommand(handlerNameArg, flags = {}) {
   const files = generateHttpHandler(options);
   s.stop("HTTP handler generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p14__namespace.outro(pc15__default.default.green(`HTTP handler '${className}' created in feature '${feature}'!`));
+  p14__namespace.outro(pc14__default.default.green(`HTTP handler '${className}' created in feature '${feature}'!`));
 }
 function generateInjectableCode(className, dependencies = [], methods = [], implementsInterface) {
   const formattedDeps = dependencies.map((dep) => ({
@@ -3216,7 +3216,7 @@ async function runInjectableCommand(classNameArg, flags = {}) {
     );
   }
   const s = p14__namespace.spinner();
-  s.start(`Generating injectable '${pc15__default.default.cyan(className)}'...`);
+  s.start(`Generating injectable '${pc14__default.default.cyan(className)}'...`);
   const options = {
     name: className,
     feature,
@@ -3230,7 +3230,7 @@ async function runInjectableCommand(classNameArg, flags = {}) {
   const files = generateInjectable(options);
   s.stop("Injectable class generated successfully!");
   printGeneratedFiles(files, options.dryRun);
-  p14__namespace.outro(pc15__default.default.green(`Injectable '${className}' created successfully!`));
+  p14__namespace.outro(pc14__default.default.green(`Injectable '${className}' created successfully!`));
 }
 async function runInteractiveMenu(flags = {}) {
   printBanner();
@@ -3344,7 +3344,7 @@ async function handleCreate(type, name, flags = {}) {
       break;
     default:
       p14__namespace.log.error(
-        pc15__default.default.red(
+        pc14__default.default.red(
           `Unknown component type: "${type}". Allowed types: feature, shared, usecase, domain, infrastructure, interface, httpHandler, injectable.`
         )
       );
@@ -3580,7 +3580,7 @@ function installNpmPackages(projectRoot, packages, pm) {
       installCmd = `npm install ${packages.join(" ")}`;
       break;
   }
-  p14__namespace.log.info(`Installing missing dependencies with ${manager}: ${pc15__default.default.cyan(packages.join(", "))}`);
+  p14__namespace.log.info(`Installing missing dependencies with ${manager}: ${pc14__default.default.cyan(packages.join(", "))}`);
   child_process.execSync(installCmd, {
     cwd: projectRoot,
     stdio: "inherit"
@@ -3736,19 +3736,19 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     );
   }
   if (type !== "shared" && type !== "feature") {
-    p14__namespace.log.error(pc15__default.default.red(`Invalid module type: "${typeArg}". Must be "shared" or "feature".`));
+    p14__namespace.log.error(pc14__default.default.red(`Invalid module type: "${typeArg}". Must be "shared" or "feature".`));
     process.exit(1);
   }
   const registryBase = getRegistryBase(projectRoot, flags.registry);
   const s = p14__namespace.spinner();
-  s.start(`Connecting to registry at ${pc15__default.default.dim(registryBase)}...`);
+  s.start(`Connecting to registry at ${pc14__default.default.dim(registryBase)}...`);
   let index;
   try {
     index = await fetchRegistryIndex(registryBase);
     s.stop("Registry index loaded.");
   } catch (err) {
-    s.stop(pc15__default.default.red("Failed to load registry index."));
-    p14__namespace.log.error(pc15__default.default.red(err.message || String(err)));
+    s.stop(pc14__default.default.red("Failed to load registry index."));
+    p14__namespace.log.error(pc14__default.default.red(err.message || String(err)));
     process.exit(1);
   }
   const availableList = type === "shared" ? index.shared : index.features;
@@ -3772,9 +3772,9 @@ async function handleImport(typeArg, nameArg, flags = {}) {
   }
   if (!candidateNames.includes(name)) {
     const closest = findClosestMatch(name, candidateNames);
-    p14__namespace.log.error(pc15__default.default.red(`\u274C Module '${name}' not found in the ${type} registry.`));
+    p14__namespace.log.error(pc14__default.default.red(`\u274C Module '${name}' not found in the ${type} registry.`));
     if (closest) {
-      p14__namespace.log.info(pc15__default.default.yellow(`Did you mean '${pc15__default.default.cyan(closest)}'?`));
+      p14__namespace.log.info(pc14__default.default.yellow(`Did you mean '${pc14__default.default.cyan(closest)}'?`));
     }
     process.exit(1);
   }
@@ -3786,7 +3786,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     try {
       manifest = await fetchModuleManifest(registryBase, modType, modName);
     } catch (err) {
-      p14__namespace.log.error(pc15__default.default.red(`Failed to fetch manifest for ${modType} '${modName}': ${err.message}`));
+      p14__namespace.log.error(pc14__default.default.red(`Failed to fetch manifest for ${modType} '${modName}': ${err.message}`));
       process.exit(1);
     }
     nodes.set(key, {
@@ -3826,7 +3826,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
   buildTopologicalOrder(rootKey);
   const resolutions = /* @__PURE__ */ new Map();
   const globalAliasMap = /* @__PURE__ */ new Map();
-  p14__namespace.log.step(`Importing ${type}: ${pc15__default.default.cyan(name)}...`);
+  p14__namespace.log.step(`Importing ${type}: ${pc14__default.default.cyan(name)}...`);
   for (const key of orderedKeys) {
     const node = nodes.get(key);
     const { type: modType, name: registryName, manifest } = node;
@@ -3859,7 +3859,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     if (programmaticPointTo) {
       if (!checkModuleExists(projectRoot, modType, programmaticPointTo)) {
         p14__namespace.log.error(
-          pc15__default.default.red(
+          pc14__default.default.red(
             `Module '${programmaticPointTo}' specified in --point-to does not exist in ${folder}.`
           )
         );
@@ -3895,7 +3895,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     }
     const existingDir = getExistingModuleDir(projectRoot, modType, registryName);
     if (!existingDir) {
-      p14__namespace.log.info(`  \u21B3 Resolving required ${modType} dependency: ${pc15__default.default.cyan(registryName)}`);
+      p14__namespace.log.info(`  \u21B3 Resolving required ${modType} dependency: ${pc14__default.default.cyan(registryName)}`);
       resolutions.set(key, {
         type: modType,
         registryName,
@@ -4126,7 +4126,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     const isOverwrite = Boolean(flags.overwrite || res.action === "overwrite");
     if (key !== rootKey) {
       p14__namespace.log.step(
-        `Importing ${res.type}: ${pc15__default.default.cyan(res.targetName)}${res.targetName !== res.registryName ? pc15__default.default.dim(` (from ${res.registryName})`) : ""}...`
+        `Importing ${res.type}: ${pc14__default.default.cyan(res.targetName)}${res.targetName !== res.registryName ? pc14__default.default.dim(` (from ${res.registryName})`) : ""}...`
       );
     }
     if (res.action === "overwrite" && !flags.dryRun) {
@@ -4145,7 +4145,7 @@ async function handleImport(typeArg, nameArg, flags = {}) {
       const localFilePath = path2__default.default.join(targetDir, file);
       if (fs9__default.default.existsSync(localFilePath) && !isOverwrite) {
         p14__namespace.log.warn(
-          `  \u21B3 Skipping existing file: ${pc15__default.default.dim(path2__default.default.relative(projectRoot, localFilePath))} (use --overwrite to replace)`
+          `  \u21B3 Skipping existing file: ${pc14__default.default.dim(path2__default.default.relative(projectRoot, localFilePath))} (use --overwrite to replace)`
         );
         continue;
       }
@@ -4157,13 +4157,13 @@ async function handleImport(typeArg, nameArg, flags = {}) {
       }
       const displayPath = path2__default.default.relative(projectRoot, localFilePath);
       totalWrittenFiles.push(displayPath);
-      p14__namespace.log.message(`  ${pc15__default.default.green("+")} ${displayPath}`);
+      p14__namespace.log.message(`  ${pc14__default.default.green("+")} ${displayPath}`);
     }
   }
   const missingNpm = getMissingNpmPackages(projectRoot, Array.from(requiredNpmPackages));
   if (missingNpm.length > 0) {
     if (flags.skipInstall || flags.dryRun) {
-      p14__namespace.log.info(`Required npm dependencies to install: ${pc15__default.default.cyan(missingNpm.join(", "))}`);
+      p14__namespace.log.info(`Required npm dependencies to install: ${pc14__default.default.cyan(missingNpm.join(", "))}`);
     } else {
       try {
         installNpmPackages(projectRoot, missingNpm);
@@ -4177,13 +4177,13 @@ async function handleImport(typeArg, nameArg, flags = {}) {
     }
   }
   if (flags.dryRun) {
-    p14__namespace.log.info(pc15__default.default.yellow("Dry run complete: No files were written to disk."));
+    p14__namespace.log.info(pc14__default.default.yellow("Dry run complete: No files were written to disk."));
   } else {
     const rootRes = resolutions.get(rootKey);
     const baseDir = getModuleBaseDir(projectRoot, type);
     const displayTarget = path2__default.default.relative(projectRoot, path2__default.default.join(baseDir, rootRes.targetName));
     p14__namespace.log.success(
-      pc15__default.default.green(
+      pc14__default.default.green(
         `Successfully imported ${type} '${name}' (${totalWrittenFiles.length} file${totalWrittenFiles.length === 1 ? "" : "s"} placed in ${displayTarget})`
       )
     );
@@ -4432,6 +4432,350 @@ function discoverAllFeatures(projectRoot) {
     dir: path2__default.default.join(featuresBase, e.name)
   })).sort((a, b) => a.name.localeCompare(b.name));
 }
+function extractClassMethods(content, className) {
+  let clean = "";
+  let inLineComment = false;
+  let inBlockComment = false;
+  let inString = null;
+  let escaped = false;
+  for (let i = 0; i < content.length; i++) {
+    const c = content[i];
+    const next = content[i + 1];
+    if (inLineComment) {
+      if (c === "\n") {
+        inLineComment = false;
+        clean += "\n";
+      } else {
+        clean += " ";
+      }
+      continue;
+    }
+    if (inBlockComment) {
+      if (c === "*" && next === "/") {
+        inBlockComment = false;
+        clean += "  ";
+        i++;
+      } else {
+        clean += c === "\n" ? "\n" : " ";
+      }
+      continue;
+    }
+    if (inString) {
+      clean += c === "\n" ? "\n" : " ";
+      if (escaped) {
+        escaped = false;
+      } else if (c === "\\") {
+        escaped = true;
+      } else if (c === inString) {
+        inString = null;
+      }
+      continue;
+    }
+    if (c === "/" && next === "/") {
+      inLineComment = true;
+      clean += "  ";
+      i++;
+      continue;
+    }
+    if (c === "/" && next === "*") {
+      inBlockComment = true;
+      clean += "  ";
+      i++;
+      continue;
+    }
+    if (c === '"' || c === "'" || c === "`") {
+      inString = c;
+      clean += " ";
+      continue;
+    }
+    clean += c;
+  }
+  const classDeclRegex = new RegExp(`(?:export\\s+(?:default\\s+)?)?class\\s+${className}\\b[^{]*\\{`);
+  const match = classDeclRegex.exec(clean);
+  if (!match) return null;
+  const classBodyStart = match.index + match[0].length - 1;
+  const methods = [];
+  let depth = 1;
+  let parenDepth = 0;
+  let atMemberStart = true;
+  const methodRegex = /^\s*(?:@[a-zA-Z0-9_$]+(?:\([^)]*\))?\s+)*(?:(public|private|protected|static)\s+)*(?:(async)\s+)?(?:(get|set)\s+)?(#?[a-zA-Z0-9_$]+)\s*(?:<[^>]+>)?\s*\(/;
+  const arrowRegex = /^\s*(?:(public|private|protected|static)\s+)?(#?[a-zA-Z0-9_$]+)\s*=\s*(?:async\s*)?\(/;
+  for (let i = classBodyStart + 1; i < clean.length && depth > 0; i++) {
+    const c = clean[i];
+    if (c === "{") {
+      depth++;
+      atMemberStart = false;
+      continue;
+    }
+    if (c === "}") {
+      depth--;
+      if (depth === 1) {
+        atMemberStart = true;
+      }
+      continue;
+    }
+    if (depth === 1) {
+      if (c === ";") {
+        atMemberStart = true;
+        parenDepth = 0;
+        continue;
+      }
+      if (c === "(") {
+        parenDepth++;
+      } else if (c === ")") {
+        parenDepth = Math.max(0, parenDepth - 1);
+      }
+      if (atMemberStart && parenDepth === 0) {
+        if (/\s/.test(c)) continue;
+        const slice = clean.slice(i);
+        const methodMatch = slice.match(methodRegex);
+        if (methodMatch) {
+          const fullMatch = methodMatch[0];
+          const beforeParen = fullMatch.slice(0, fullMatch.lastIndexOf("(")).trim();
+          const tokens = beforeParen.split(/\s+/).filter(Boolean);
+          const rawName = tokens[tokens.length - 1] || "";
+          const methodName = rawName.replace(/<.*$/, "");
+          const controlKeywords = ["if", "for", "while", "switch", "catch", "with"];
+          if (!controlKeywords.includes(methodName)) {
+            const isPrivate = tokens.includes("private") || tokens.includes("protected") || methodName.startsWith("#");
+            const isAsync = tokens.includes("async");
+            const isPublic = !isPrivate;
+            const lineNum = content.slice(0, i).split("\n").length;
+            const lineCode = content.split("\n")[lineNum - 1]?.trim() || "";
+            methods.push({
+              name: methodName,
+              isAsync,
+              isPublic,
+              line: lineNum,
+              code: lineCode
+            });
+            i += fullMatch.length - 1;
+            parenDepth = 1;
+            atMemberStart = false;
+            continue;
+          }
+        }
+        const arrowMatch = slice.match(arrowRegex);
+        if (arrowMatch) {
+          const fullMatch = arrowMatch[0];
+          const beforeEquals = fullMatch.split("=")[0].trim();
+          const tokens = beforeEquals.split(/\s+/).filter(Boolean);
+          const rawName = tokens[tokens.length - 1] || "";
+          const isPrivate = tokens.includes("private") || tokens.includes("protected") || rawName.startsWith("#");
+          const isAsync = fullMatch.includes("async");
+          const isPublic = !isPrivate;
+          const lineNum = content.slice(0, i).split("\n").length;
+          const lineCode = content.split("\n")[lineNum - 1]?.trim() || "";
+          methods.push({
+            name: rawName,
+            isAsync,
+            isPublic,
+            line: lineNum,
+            code: lineCode
+          });
+          i += fullMatch.length - 1;
+          parenDepth = 1;
+          atMemberStart = false;
+          continue;
+        }
+        atMemberStart = false;
+      }
+    }
+  }
+  return methods;
+}
+function checkUseCaseShape(featureName, filePath, relativePath, content, addViolation) {
+  const fileName = path2__default.default.basename(filePath);
+  const lines = content.split(/\r?\n/);
+  const classMatch = content.match(/(?:export\s+(?:default\s+)?)?class\s+([A-Za-z0-9_]+)/);
+  if (!classMatch) {
+    addViolation({
+      feature: featureName,
+      layer: "useCases",
+      file: filePath,
+      relativePath,
+      line: 1,
+      category: "Use Case Shape Violation",
+      code: lines[0]?.trim() || "",
+      ruleId: "U_SHAPE_CLASS",
+      severity: "error",
+      advice: `Use case file '${fileName}' must define and export a class.`,
+      fixExample: {
+        bad: "// Missing class definition",
+        good: `export class ${fileName.replace(/\.(ts|js)$/, "")} { ... }`
+      }
+    });
+    return;
+  }
+  const className = classMatch[1];
+  let classLine = 1;
+  for (let i = 0; i < lines.length; i++) {
+    if (new RegExp(`(?:export\\s+(?:default\\s+)?)?class\\s+${className}\\b`).test(lines[i])) {
+      classLine = i + 1;
+      break;
+    }
+  }
+  if (!/@MakeInjectable\b/.test(content)) {
+    addViolation({
+      feature: featureName,
+      layer: "useCases",
+      file: filePath,
+      relativePath,
+      line: classLine,
+      category: "Use Case Shape Violation",
+      code: lines[classLine - 1]?.trim() || `class ${className}`,
+      ruleId: "U_SHAPE_DECORATOR",
+      severity: "error",
+      advice: `Use case class '${className}' in '${fileName}' must be decorated with @MakeInjectable.`,
+      fixExample: {
+        bad: lines[classLine - 1]?.trim() || `class ${className}`,
+        good: `@MakeInjectable
+export class ${className} { ... }`
+      }
+    });
+  }
+  const hasAsyncExecute = /(?:public\s+)?async\s+execute\s*(?:<[^>]+>)?\s*\(/.test(content);
+  if (!hasAsyncExecute) {
+    const hasSyncExecute = /(?:public\s+)?execute\s*(?:<[^>]+>)?\s*\(/.test(content);
+    addViolation({
+      feature: featureName,
+      layer: "useCases",
+      file: filePath,
+      relativePath,
+      line: classLine,
+      category: "Use Case Shape Violation",
+      code: lines[classLine - 1]?.trim() || `class ${className}`,
+      ruleId: "U_SHAPE_EXECUTE",
+      severity: "error",
+      advice: hasSyncExecute ? `Use case class '${className}' in '${fileName}' must have an 'async execute' method (found synchronous 'execute').` : `Use case class '${className}' in '${fileName}' must implement an 'async execute(...)' method.`,
+      fixExample: {
+        bad: hasSyncExecute ? "execute(props: ...) { ... }" : `class ${className} { ... }`,
+        good: "async execute(props: ...): Promise<...> { ... }"
+      }
+    });
+  }
+  const classMethods = extractClassMethods(content, className);
+  if (classMethods) {
+    const extraPublicMethods = classMethods.filter(
+      (m) => m.isPublic && m.name !== "constructor" && m.name !== "execute"
+    );
+    for (const m of extraPublicMethods) {
+      addViolation({
+        feature: featureName,
+        layer: "useCases",
+        file: filePath,
+        relativePath,
+        line: m.line,
+        category: "Use Case Shape Violation",
+        code: m.code || `public ${m.name}(...)`,
+        ruleId: "U_SHAPE_ONLY_EXECUTE",
+        severity: "error",
+        advice: `Use case class '${className}' in '${fileName}' has disallowed public method '${m.name}'. The only allowed public methods are constructor and async execute. Extract extra methods into their own use cases, or make them private.`,
+        fixExample: {
+          bad: m.code || `${m.name}(...) { ... }`,
+          good: `// Extract '${m.name}' into its own dedicated Use Case, or make it private if it is internal helper logic:
+private ${m.name}(...) { ... }`
+        }
+      });
+    }
+  }
+}
+function checkServiceShape(featureName, filePath, relativePath, content, addViolation) {
+  const fileName = path2__default.default.basename(filePath);
+  const lines = content.split(/\r?\n/);
+  const classMatch = content.match(/(?:export\s+(?:default\s+)?)?class\s+([A-Za-z0-9_]+)/);
+  if (!classMatch) {
+    addViolation({
+      feature: featureName,
+      layer: "services",
+      file: filePath,
+      relativePath,
+      line: 1,
+      category: "Service Shape Violation",
+      code: lines[0]?.trim() || "",
+      ruleId: "S_SHAPE_CLASS",
+      severity: "error",
+      advice: `Service file '${fileName}' must define and export a class.`,
+      fixExample: {
+        bad: "// Missing class definition",
+        good: `export class ${fileName.replace(/\.(ts|js)$/, "")} { ... }`
+      }
+    });
+    return;
+  }
+  const className = classMatch[1];
+  let classLine = 1;
+  for (let i = 0; i < lines.length; i++) {
+    if (new RegExp(`(?:export\\s+(?:default\\s+)?)?class\\s+${className}\\b`).test(lines[i])) {
+      classLine = i + 1;
+      break;
+    }
+  }
+  if (!/@MakeInjectable\b/.test(content)) {
+    addViolation({
+      feature: featureName,
+      layer: "services",
+      file: filePath,
+      relativePath,
+      line: classLine,
+      category: "Service Shape Violation",
+      code: lines[classLine - 1]?.trim() || `class ${className}`,
+      ruleId: "S_SHAPE_DECORATOR",
+      severity: "error",
+      advice: `Service class '${className}' in '${fileName}' must be decorated with @MakeInjectable.`,
+      fixExample: {
+        bad: lines[classLine - 1]?.trim() || `class ${className}`,
+        good: `@MakeInjectable
+export class ${className} { ... }`
+      }
+    });
+  }
+  const hasAsyncExecute = /(?:public\s+)?async\s+execute\s*(?:<[^>]+>)?\s*\(/.test(content);
+  if (!hasAsyncExecute) {
+    const hasSyncExecute = /(?:public\s+)?execute\s*(?:<[^>]+>)?\s*\(/.test(content);
+    addViolation({
+      feature: featureName,
+      layer: "services",
+      file: filePath,
+      relativePath,
+      line: classLine,
+      category: "Service Shape Violation",
+      code: lines[classLine - 1]?.trim() || `class ${className}`,
+      ruleId: "S_SHAPE_EXECUTE",
+      severity: "error",
+      advice: hasSyncExecute ? `Service class '${className}' in '${fileName}' must have an 'async execute' method (found synchronous 'execute').` : `Service class '${className}' in '${fileName}' must implement an 'async execute(...)' method.`,
+      fixExample: {
+        bad: hasSyncExecute ? "execute(props: ...) { ... }" : `class ${className} { ... }`,
+        good: "async execute(props: ...): Promise<...> { ... }"
+      }
+    });
+  }
+  const classMethods = extractClassMethods(content, className);
+  if (classMethods) {
+    const extraPublicMethods = classMethods.filter(
+      (m) => m.isPublic && m.name !== "constructor" && m.name !== "execute"
+    );
+    for (const m of extraPublicMethods) {
+      addViolation({
+        feature: featureName,
+        layer: "services",
+        file: filePath,
+        relativePath,
+        line: m.line,
+        category: "Service Shape Violation",
+        code: m.code || `public ${m.name}(...)`,
+        ruleId: "S_SHAPE_ONLY_EXECUTE",
+        severity: "error",
+        advice: `Service class '${className}' in '${fileName}' has disallowed public method '${m.name}'. The only allowed public methods are constructor and async execute. If a service has multiple public methods, those should be on their own services instead of being cramped in a single service.`,
+        fixExample: {
+          bad: m.code || `${m.name}(...) { ... }`,
+          good: `// Extract '${m.name}' into its own dedicated Service, or make it private if it is internal helper logic:
+private ${m.name}(...) { ... }`
+        }
+      });
+    }
+  }
+}
 function lintCodebase(options = {}) {
   const startTime = Date.now();
   const projectRoot = options.projectRoot || findProjectRoot(options.targetDir || process.cwd());
@@ -4449,13 +4793,9 @@ function lintCodebase(options = {}) {
       featureResult.passed = false;
     }
     if (failFast) {
-      const errorMsg = `[FAIL FAST] Dependency rule violation detected:
-   Feature:     ${v.feature}
-   Category:    ${v.category}
-   Rule:        ${v.ruleId}
-   Location:    ${v.relativePath}:${v.line}
-   Code:        ${v.code}
-   Explanation: ${v.advice}`;
+      const errorMsg = `Dependency rule violation detected in ${v.relativePath}:${v.line}:
+[${v.category}] ${v.advice}
+Code: ${v.code}`;
       throw new DependencyRuleError(errorMsg, [v], true);
     }
   };
@@ -4479,6 +4819,14 @@ function lintCodebase(options = {}) {
       if (!layer) continue;
       const content = fs9__default.default.readFileSync(file, "utf-8");
       const statements = extractImportStatements(content);
+      const baseName = path2__default.default.basename(file);
+      const isBarrel = baseName === "index.ts" || baseName === "index.js";
+      if (layer === "useCases" && !isBarrel) {
+        checkUseCaseShape(feat.name, file, relPath, content, addViolation);
+      }
+      if (layer === "services" && !isBarrel) {
+        checkServiceShape(feat.name, file, relPath, content, addViolation);
+      }
       if (layer === "domain") {
         const lines = content.split(/\r?\n/);
         for (let i = 0; i < lines.length; i++) {
@@ -4889,6 +5237,24 @@ function lintCodebase(options = {}) {
               }
             });
           }
+          if (target.targetLayer === "services") {
+            addViolation({
+              feature: feat.name,
+              layer,
+              file,
+              relativePath: relPath,
+              line: stmt.line,
+              category: "Presentation Layer Violation",
+              code: stmt.rawCode,
+              ruleId: "P4_DIRECT_SERVICE",
+              severity: "error",
+              advice: "Presentation handlers must not depend on services directly. They must use use cases, and use cases will then depend on the service.",
+              fixExample: {
+                bad: stmt.rawCode,
+                good: "// Inject a Use Case via static deps instead of a Service."
+              }
+            });
+          }
         }
       }
     }
@@ -4943,87 +5309,23 @@ ${compiledDetails}
 }
 
 // src/commands/lint.ts
-function printLintBanner(mode) {
-  console.log("");
-  const title = " Mason Clean Architecture Dependency Linter ";
-  const line = "\u2501".repeat(title.length + 2);
-  console.log(pc15__default.default.cyan(` \u250F${line}\u2513`));
-  console.log(` ${pc15__default.default.cyan("\u2503")} ${pc15__default.default.bgCyan(pc15__default.default.black(title))} ${pc15__default.default.cyan("\u2503")}`);
-  console.log(pc15__default.default.cyan(` \u2517${line}\u251B`));
-  const modeText = mode === "failFast" ? `${pc15__default.default.yellow("Fail-Fast")} ${pc15__default.default.dim("(default: stops at first error)")}` : `${pc15__default.default.magenta("Complete")} ${pc15__default.default.dim("(--complete: compiles all errors)")}`;
-  console.log(` Mode: ${modeText}`);
-  console.log("");
-}
-function formatViolation(v, showFixHint = true) {
+function formatViolation(v) {
   const lines = [];
-  const categoryBadge = pc15__default.default.red(pc15__default.default.bold(`[${v.category}]`));
-  const location = pc15__default.default.white(`${v.relativePath}:${pc15__default.default.yellow(String(v.line))}`);
-  lines.push(`   ${categoryBadge} ${location}`);
-  lines.push(`   ${pc15__default.default.dim("Rule ID:")} ${pc15__default.default.yellow(v.ruleId)}`);
-  lines.push(`   ${pc15__default.default.dim("Code:")}    ${pc15__default.default.magenta(v.code)}`);
-  lines.push(`   ${pc15__default.default.dim("Advice:")}  ${pc15__default.default.cyan(v.advice)}`);
-  if (showFixHint && v.fixExample) {
-    lines.push(`   ${pc15__default.default.dim("Example:")}`);
-    lines.push(`     ${pc15__default.default.red(`- ${v.fixExample.bad}`)}`);
-    lines.push(`     ${pc15__default.default.green(`+ ${v.fixExample.good}`)}`);
-  }
-  return lines.join("\n");
-}
-function formatFeatureResult(res, options = {}) {
-  const lines = [];
-  if (res.passed) {
-    lines.push(
-      ` ${pc15__default.default.green("\u2714")} ${pc15__default.default.bold(res.featureName)} ${pc15__default.default.dim(
-        `(${res.scannedFilesCount} files checked - clean)`
-      )}`
-    );
-    return lines.join("\n");
-  }
-  const countBadge = pc15__default.default.red(
-    `(${res.violations.length} violation${res.violations.length > 1 ? "s" : ""})`
+  lines.push(pc14__default.default.underline(pc14__default.default.cyan(v.relativePath)) + pc14__default.default.dim(":") + pc14__default.default.yellow(String(v.line)));
+  const gutter = `${String(v.line).padStart(4, " ")} | `;
+  lines.push(pc14__default.default.dim(gutter) + v.code);
+  const categoryShort = v.category.replace(" Violation", "");
+  lines.push(
+    "       " + pc14__default.default.red(pc14__default.default.bold("\u2716")) + " " + pc14__default.default.red(`[${categoryShort}]`) + " " + v.advice
   );
-  lines.push(`
- ${pc15__default.default.red("\u2716")} ${pc15__default.default.bold(pc15__default.default.white(res.featureName))} ${countBadge}`);
-  lines.push(`   ${pc15__default.default.dim("Path:")} ${res.featureDir}`);
-  lines.push("");
-  for (const v of res.violations) {
-    lines.push(formatViolation(v, options.fixHint !== false));
-    lines.push("");
+  if (v.fixExample?.good) {
+    lines.push("       " + pc14__default.default.dim("\u2192") + " " + pc14__default.default.dim(v.fixExample.good));
   }
   return lines.join("\n");
 }
-function printTerminalReport(summary, options = {}) {
-  for (const res of summary.results) {
-    const formatted = formatFeatureResult(res, options);
-    if (formatted.trim()) {
-      console.log(formatted);
-    }
-  }
-  console.log("\u2501".repeat(70));
-  const statusIcon = summary.totalViolations === 0 ? pc15__default.default.green("\u2714 PASS") : pc15__default.default.red("\u2716 FAIL");
-  console.log(
-    ` ${statusIcon}  ${pc15__default.default.bold("Dependency Rules Audit Result")}  ${pc15__default.default.dim(
-      `(${summary.durationMs}ms)`
-    )}`
-  );
-  console.log(
-    `   ${pc15__default.default.bold("Features:")}   ${pc15__default.default.cyan(String(summary.totalFeatures))} total  |  ${pc15__default.default.green(
-      String(summary.cleanFeatures)
-    )} clean  |  ${summary.violatedFeatures > 0 ? pc15__default.default.red(String(summary.violatedFeatures)) : pc15__default.default.green("0")} with violations`
-  );
-  console.log(
-    `   ${pc15__default.default.bold("Violations:")} ${summary.totalViolations > 0 ? pc15__default.default.red(pc15__default.default.bold(String(summary.totalViolations))) : pc15__default.default.green("0")} rule violations found`
-  );
-  console.log("\u2501".repeat(70));
-  console.log("");
-}
 async function handleLint(flags = {}) {
   const complete = Boolean(flags.complete);
-  const mode = complete ? "complete" : "failFast";
   const quiet = Boolean(flags.quiet);
-  if (!quiet) {
-    printLintBanner(mode);
-  }
   const options = {
     complete,
     quiet,
@@ -5034,14 +5336,23 @@ async function handleLint(flags = {}) {
   };
   try {
     const summary = lintCodebase(options);
-    if (!quiet) {
-      printTerminalReport(summary, options);
-    }
     if (summary.totalViolations > 0) {
+      if (!quiet) {
+        console.log("");
+        for (const v of summary.allViolations) {
+          console.log(formatViolation(v));
+          console.log("");
+        }
+        console.log(
+          pc14__default.default.red(
+            `\u2716 Dependency rules check failed with ${summary.totalViolations} error${summary.totalViolations > 1 ? "s" : ""} across ${summary.violatedFeatures} feature${summary.violatedFeatures > 1 ? "s" : ""} (${summary.totalFeatures} features scanned).`
+          )
+        );
+        console.log("");
+      }
       const errorHeader = `Dependency rule audit failed with ${summary.totalViolations} violation(s) across ${summary.violatedFeatures} feature(s):`;
       const compiledDetails = summary.allViolations.map(
         (v, i) => `${i + 1}. [${v.category}] ${v.relativePath}:${v.line}
-   Rule:   ${v.ruleId}
    Code:   ${v.code}
    Advice: ${v.advice}`
       ).join("\n\n");
@@ -5052,20 +5363,22 @@ ${compiledDetails}
     }
     if (!quiet) {
       console.log(
-        pc15__default.default.green(`\u2714 All dependency rules are being followed! (${summary.totalFeatures} features checked)`)
+        pc14__default.default.green(
+          `\u2714 Dependency rules verified across ${summary.totalFeatures} feature${summary.totalFeatures === 1 ? "" : "s"}.`
+        )
       );
-      console.log("");
     }
     return summary;
   } catch (err) {
     if (err instanceof DependencyRuleError && err.isFailFast) {
       if (!quiet) {
-        console.log(pc15__default.default.red(`
-\u2716 [FAIL FAST] Terminating on first detected dependency rule violation:`));
+        console.log("");
         const v = err.violations[0];
         if (v) {
-          console.log(formatViolation(v, options.fixHint !== false));
+          console.log(formatViolation(v));
+          console.log("");
         }
+        console.log(pc14__default.default.red(`\u2716 Dependency rules check failed (1 error).`));
         console.log("");
       }
     }
@@ -5079,7 +5392,7 @@ function createCli() {
   cli.command("[...args]", "Interactive scaffolding and import wizard").option("-d, --dry-run", "Preview changes without writing to disk").option("-o, --overwrite", "Overwrite existing files").option("-y, --yes", "Accept defaults and skip interactive prompts").option("--registry", "Run in registry mode").option("--point-to <mapping>", "Point a dependency to an existing local module (e.g. --point-to time:mytime)").option("--alias <mapping>", "Import a dependency fresh under an alias name (e.g. --alias time:time-mason)").option("--tests", "Include test files (use --no-tests to exclude)").action(async (args, flags) => {
     if (args && args.length > 0) {
       p14__namespace.log.error(
-        pc15__default.default.red(
+        pc14__default.default.red(
           `Unknown command: "${args.join(" ")}". Use --help to list available commands.`
         )
       );
@@ -5198,6 +5511,12 @@ function createCli() {
         targetDir: target || flags.target || flags.dest
       });
     } catch (err) {
+      if (err instanceof DependencyRuleError) {
+        if (process.env.VITEST) {
+          throw err;
+        }
+        process.exit(1);
+      }
       handleCliError(err);
     }
   });
@@ -5232,7 +5551,7 @@ function handleCliError(err) {
     process.exit(0);
   }
   const message = err instanceof Error ? err.message : String(err);
-  p14__namespace.log.error(pc15__default.default.red(`Error: ${message}`));
+  p14__namespace.log.error(pc14__default.default.red(`Error: ${message}`));
   if (process.env.VITEST) {
     throw err;
   }