@autometa/cli 1.0.0-rc.5 → 1.0.0-rc.7

package/dist/bin.cjs

@@ -2010,19 +2010,112 @@ function detectRunner(config, cwd) {
   }
   return "default";
 }
+function normalizeGlobLikePath(input) {
+  return input.replace(/\\/g, "/").replace(/^\.\//u, "");
+}
+function patternIsUnderRoot(pattern, root) {
+  const p = normalizeGlobLikePath(pattern);
+  const r = normalizeGlobLikePath(root).replace(/\/+$/u, "");
+  if (!r) {
+    return false;
+  }
+  return p === r || p.startsWith(`${r}/`);
+}
+function filterPatternsByGroupsAndModules(options) {
+  const { patterns, groups, modules, config, verbose } = options;
+  const hasGroupSelection = (groups?.length ?? 0) > 0;
+  const hasModuleSelection = (modules?.length ?? 0) > 0;
+  const hasAnySelection = hasGroupSelection || hasModuleSelection;
+  const hasExplicitPatterns = patterns.length > 0;
+  if (hasExplicitPatterns) {
+    if (hasAnySelection && verbose) {
+      const shouldWarn = (() => {
+        const configGroups = config.modules?.groups;
+        if (!configGroups) {
+          return true;
+        }
+        if (hasGroupSelection) {
+          const allowedGroups = new Set(groups);
+          const allowedRoots = Object.entries(configGroups).filter(([group]) => allowedGroups.has(group)).map(([, groupConfig]) => groupConfig.root);
+          if (allowedRoots.length > 0) {
+            return patterns.some(
+              (pattern) => !allowedRoots.some((root) => patternIsUnderRoot(pattern, root))
+            );
+          }
+        }
+        return true;
+      })();
+      if (shouldWarn) {
+        console.warn(
+          "[autometa] Note: when you pass explicit feature patterns, they are used as-is. Group/module filters (-g/-m) affect module/step loading, but do not automatically filter your feature patterns."
+        );
+      }
+    }
+    return patterns;
+  }
+  const roots = [...config.roots.features];
+  if (hasAnySelection && config.modules?.groups) {
+    const allowedGroups = hasGroupSelection ? new Set(groups) : new Set(Object.keys(config.modules.groups));
+    if (hasModuleSelection && modules && modules.length > 0) {
+      const modulePatterns = [];
+      const relativeRoots = config.modules.relativeRoots?.features ?? [".features/**/*.feature"];
+      for (const [groupName, groupConfig] of Object.entries(config.modules.groups)) {
+        if (!allowedGroups.has(groupName)) {
+          continue;
+        }
+        const groupRoot = groupConfig.root;
+        const groupModules = groupConfig.modules ?? [];
+        for (const moduleName of modules) {
+          const moduleExists = Array.isArray(groupModules) && groupModules.some((m) => {
+            if (typeof m === "string") {
+              return m === moduleName || m.endsWith(`/${moduleName}`) || m.endsWith(`:${moduleName}`);
+            }
+            return false;
+          });
+          if (moduleExists) {
+            for (const relativeRoot of relativeRoots) {
+              const normalizedRelative = relativeRoot.replace(/^\.\//, "");
+              const modulePath = path2.join(groupRoot, moduleName, normalizedRelative);
+              modulePatterns.push(modulePath);
+            }
+          }
+        }
+      }
+      if (modulePatterns.length > 0) {
+        return modulePatterns;
+      }
+    }
+    const allowedRoots = Object.entries(config.modules.groups).filter(([group]) => allowedGroups.has(group)).map(([, groupConfig]) => groupConfig.root);
+    const filtered = roots.filter(
+      (pattern) => allowedRoots.some((root) => patternIsUnderRoot(pattern, root))
+    );
+    if (filtered.length > 0) {
+      return filtered;
+    }
+  }
+  return roots;
+}
 async function orchestrate(options) {
-  const { cwd, config, patterns = [], runnerArgs = [], dryRun = false, watch = false, verbose = false } = options;
+  const { cwd, config, patterns = [], runnerArgs = [], dryRun = false, watch = false, verbose = false, groups, modules } = options;
   const runner = detectRunner(config, cwd);
   if (verbose) {
     console.log(`[autometa] Detected runner: ${runner}`);
   }
+  const filteredPatterns = filterPatternsByGroupsAndModules({
+    patterns,
+    groups,
+    modules,
+    config,
+    cwd,
+    verbose
+  });
   switch (runner) {
     case "vitest":
-      return spawnVitest({ cwd, patterns, runnerArgs, dryRun, watch, verbose });
+      return spawnVitest({ cwd, patterns: filteredPatterns, runnerArgs, dryRun, watch, verbose });
     case "jest":
-      return spawnJest({ cwd, patterns, runnerArgs, dryRun, watch, verbose });
+      return spawnJest({ cwd, patterns: filteredPatterns, runnerArgs, dryRun, watch, verbose });
     case "playwright":
-      return spawnPlaywright({ cwd, patterns, runnerArgs, dryRun, watch, verbose });
+      return spawnPlaywright({ cwd, patterns: filteredPatterns, runnerArgs, dryRun, watch, verbose });
     case "default":
       return { success: true, exitCode: 0, runner: "default" };
   }
@@ -2034,7 +2127,8 @@ async function spawnVitest(options) {
     args.push("run");
   }
   if (patterns.length > 0) {
-    args.push(...patterns);
+    const expanded = await expandFilePatterns(patterns, cwd);
+    args.push(...expanded.length > 0 ? expanded : patterns);
   }
   if (dryRun) {
     args.push("--passWithNoTests");
@@ -2136,17 +2230,53 @@ var STEP_FILE_EXTENSIONS = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx"
 var STEP_FALLBACK_GLOB = "**/*.{ts,tsx,js,jsx,mjs,cjs,mts,cts}";
 var FEATURE_FALLBACK_GLOB = "**/*.feature";
 var ROOT_LOAD_ORDER = ["parameterTypes", "support", "hooks", "app"];
-function normalizeGlobLikePath(input) {
+var GLOB_MAGIC_CHARACTERS = /* @__PURE__ */ new Set(["*", "?", "[", "]", "{", "}", "(", ")", "!"]);
+function normalizeGlobLikePath2(input) {
   return input.replace(/\\/g, "/").replace(/^\.\//u, "");
 }
-function patternIsUnderRoot(pattern, root) {
-  const p = normalizeGlobLikePath(pattern);
-  const r = normalizeGlobLikePath(root).replace(/\/+$/u, "");
+function patternIsUnderRoot2(pattern, root) {
+  const p = normalizeGlobLikePath2(pattern);
+  const r = normalizeGlobLikePath2(root).replace(/\/+$/u, "");
   if (!r) {
     return false;
   }
   return p === r || p.startsWith(`${r}/`);
 }
+function inferGlobBaseDirectory(pattern) {
+  const normalized = normalizeGlobLikePath2(pattern).replace(/^!/u, "");
+  for (let i = 0; i < normalized.length; i += 1) {
+    if (!GLOB_MAGIC_CHARACTERS.has(normalized[i] ?? "")) {
+      continue;
+    }
+    const prefix = normalized.slice(0, i);
+    const lastSlash = prefix.lastIndexOf("/");
+    if (lastSlash <= 0) {
+      return ".";
+    }
+    const base = prefix.slice(0, lastSlash);
+    return base || ".";
+  }
+  if (path2.extname(normalized)) {
+    return path2.dirname(normalized);
+  }
+  return normalized || ".";
+}
+function inferFeatureRootDirectories(patterns, cwd) {
+  if (!patterns || patterns.length === 0) {
+    return [];
+  }
+  const roots = /* @__PURE__ */ new Set();
+  for (const entry of patterns) {
+    const trimmed = entry.trim();
+    if (!trimmed) {
+      continue;
+    }
+    const base = hasGlobMagic(trimmed) ? inferGlobBaseDirectory(trimmed) : trimmed;
+    const resolved = path2.resolve(cwd, base);
+    roots.add(resolved.replace(/\/+$/u, ""));
+  }
+  return Array.from(roots).sort((a, b) => b.length - a.length);
+}
 function flattenModuleDeclarations(declarations, prefix = []) {
   if (!declarations || declarations.length === 0) {
     return [];
@@ -2230,6 +2360,48 @@ function resolveFileScope(fileAbs, groupIndex) {
   }
   return { kind: "root" };
 }
+function resolveHoistedDirectoryScope(options) {
+  const rootAbs = options.hoistedFeatureRootsAbs.find(
+    (root) => isPathUnderRoot(options.featureAbsPath, root)
+  );
+  if (!rootAbs) {
+    return { kind: "root" };
+  }
+  const rel = path2.relative(rootAbs, options.featureAbsPath);
+  const segments = normalizePathSegments(rel);
+  const dirSegments = segments.slice(0, -1);
+  if (dirSegments.length === 0) {
+    return { kind: "root" };
+  }
+  const group = dirSegments[0];
+  if (!group) {
+    return { kind: "root" };
+  }
+  const groupEntry = options.groupIndex.find((entry) => entry.group === group);
+  if (!groupEntry) {
+    if (options.strict) {
+      throw new Error(
+        `[autometa] Feature "${options.featureAbsPath}" is under "${rootAbs}" and implies group "${group}", but "${group}" is not declared in config.modules.groups.`
+      );
+    }
+    return { kind: "root" };
+  }
+  const moduleSegments = dirSegments.slice(1);
+  if (moduleSegments.length === 0) {
+    return { kind: "group", group };
+  }
+  for (const modulePath of groupEntry.modulePaths) {
+    if (startsWithSegments(moduleSegments, modulePath)) {
+      return { kind: "module", group, modulePath };
+    }
+  }
+  if (options.strict) {
+    throw new Error(
+      `[autometa] Feature "${options.featureAbsPath}" is under "${rootAbs}" and implies module "${group}:${moduleSegments.join(":")}", but no matching module is declared in config.modules.groups.${group}.modules.`
+    );
+  }
+  return { kind: "group", group };
+}
 function parseScopeOverrideTag(tags) {
   if (!tags || tags.length === 0) {
     return void 0;
@@ -2253,15 +2425,36 @@ function parseScopeOverrideTag(tags) {
   }
   return void 0;
 }
-function resolveFeatureScope(featureAbsPath, feature, groupIndex) {
-  const override = parseScopeOverrideTag(feature.tags);
+function resolveFeatureScope(options) {
+  const override = parseScopeOverrideTag(options.feature.tags);
+  const fileScope = resolveFileScope(options.featureAbsPath, options.groupIndex);
+  const inferred = (() => {
+    if (fileScope.kind !== "root") {
+      return fileScope;
+    }
+    if (options.hoistedFeatureScopingMode !== "directory") {
+      return fileScope;
+    }
+    return resolveHoistedDirectoryScope({
+      featureAbsPath: options.featureAbsPath,
+      hoistedFeatureRootsAbs: options.hoistedFeatureRootsAbs,
+      groupIndex: options.groupIndex,
+      strict: options.hoistedFeatureScopingStrict
+    });
+  })();
   if (override) {
     if (override.modulePath && override.modulePath.length > 0) {
       return { kind: "module", group: override.group, modulePath: override.modulePath };
     }
+    if (inferred.kind === "module" && inferred.group === override.group) {
+      return inferred;
+    }
+    if (inferred.kind === "group" && inferred.group === override.group) {
+      return inferred;
+    }
     return { kind: "group", group: override.group };
   }
-  return resolveFileScope(featureAbsPath, groupIndex);
+  return inferred;
 }
 function isVisibleStepScope(stepScope, featureScope) {
   if (featureScope.kind === "root") {
@@ -2354,7 +2547,14 @@ function createFeatureScopePlan(feature, basePlan, options) {
   const scopingMode = options.config.modules?.stepScoping ?? "global";
   const useScopedSteps = scopingMode === "scoped" && options.groupIndex.length > 0;
   const allSteps = Array.from(basePlan.stepsById.values());
-  const featureFileScope = useScopedSteps ? resolveFeatureScope(options.featureAbsPath, feature, options.groupIndex) : { kind: "root" };
+  const featureFileScope = useScopedSteps ? resolveFeatureScope({
+    featureAbsPath: options.featureAbsPath,
+    feature,
+    groupIndex: options.groupIndex,
+    hoistedFeatureRootsAbs: options.hoistedFeatureRootsAbs,
+    hoistedFeatureScopingMode: options.config.modules?.hoistedFeatures?.scope ?? "tag",
+    hoistedFeatureScopingStrict: options.config.modules?.hoistedFeatures?.strict ?? true
+  }) : { kind: "root" };
   const visibleSteps = useScopedSteps ? allSteps.filter((definition) => {
     const file = definition.source?.file;
     const stepScope = file ? resolveFileScope(path2.resolve(options.cwd, file), options.groupIndex) : { kind: "root" };
@@ -2481,7 +2681,9 @@ async function runFeatures(options = {}) {
       ...options.runnerArgs ? { runnerArgs: options.runnerArgs } : {},
       ...options.dryRun !== void 0 ? { dryRun: options.dryRun } : {},
       ...options.watch !== void 0 ? { watch: options.watch } : {},
-      ...options.verbose !== void 0 ? { verbose: options.verbose } : {}
+      ...options.verbose !== void 0 ? { verbose: options.verbose } : {},
+      groups: options.groups,
+      modules: options.modules
     });
     if (orchestratorResult.runner !== "default") {
       return {
@@ -2523,7 +2725,7 @@ async function runFeatures(options = {}) {
         const allowedRoots = Object.entries(groups).filter(([group]) => allowedGroups.has(group)).map(([, groupConfig]) => groupConfig.root);
         if (allowedRoots.length > 0) {
           return patterns.some(
-            (pattern) => !allowedRoots.some((root) => patternIsUnderRoot(pattern, root))
+            (pattern) => !allowedRoots.some((root) => patternIsUnderRoot2(pattern, root))
           );
         }
       }
@@ -2544,7 +2746,7 @@ async function runFeatures(options = {}) {
       const allowedGroups = (options.groups?.length ?? 0) > 0 ? new Set(options.groups) : new Set(Object.keys(executorConfig.modules.groups));
       const allowedRoots = Object.entries(executorConfig.modules.groups).filter(([group]) => allowedGroups.has(group)).map(([, groupConfig]) => groupConfig.root);
       const filtered = roots.filter(
-        (pattern) => allowedRoots.some((root) => patternIsUnderRoot(pattern, root))
+        (pattern) => allowedRoots.some((root) => patternIsUnderRoot2(pattern, root))
       );
       if (filtered.length > 0) {
         return filtered;
@@ -2575,6 +2777,7 @@ async function runFeatures(options = {}) {
   }
   const groupIndex = buildGroupIndex(executorConfig, cwd);
   const environmentIndex = indexStepsEnvironments(stepsEnvironments, cwd, groupIndex);
+  const hoistedFeatureRootsAbs = inferFeatureRootDirectories(executorConfig.roots.features, cwd);
   for (const featurePath of featureFiles) {
     const feature = await readFeatureFile(featurePath, cwd);
     const featureAbsPath = path2.resolve(cwd, featurePath);
@@ -2582,7 +2785,9 @@ async function runFeatures(options = {}) {
       featureAbsPath,
       feature,
       environmentIndex,
-      groupIndex
+      groupIndex,
+      executorConfig,
+      hoistedFeatureRootsAbs
     );
     runner.CucumberRunner.setSteps(selectedStepsEnvironment);
     const basePlan = selectedStepsEnvironment.getPlan();
@@ -2590,7 +2795,8 @@ async function runFeatures(options = {}) {
       featureAbsPath,
       cwd,
       config: executorConfig,
-      groupIndex
+      groupIndex,
+      hoistedFeatureRootsAbs
     });
     const coordinated = selectedStepsEnvironment.coordinateFeature({
       feature,
@@ -2697,8 +2903,15 @@ function indexStepsEnvironments(environments, cwd, groupIndex) {
   }
   return entries;
 }
-function resolveFeatureStepsEnvironment(featureAbsPath, feature, environments, groupIndex) {
-  const featureScope = resolveFeatureScope(featureAbsPath, feature, groupIndex);
+function resolveFeatureStepsEnvironment(featureAbsPath, feature, environments, groupIndex, config, hoistedFeatureRootsAbs) {
+  const featureScope = resolveFeatureScope({
+    featureAbsPath,
+    feature,
+    groupIndex,
+    hoistedFeatureRootsAbs,
+    hoistedFeatureScopingMode: config.modules?.hoistedFeatures?.scope ?? "tag",
+    hoistedFeatureScopingStrict: config.modules?.hoistedFeatures?.strict ?? true
+  });
   if (featureScope.kind === "root") {
     const root = environments.find((entry) => entry.kind === "root");
     return root?.environment ?? environments[0]?.environment ?? runner.CucumberRunner.steps();