@step-forge/step-forge 0.0.7 → 0.0.8

package/package.json

@@ -1,13 +1,21 @@
 {
   "name": "@step-forge/step-forge",
-  "version": "0.0.7",
+  "version": "0.0.8",
   "module": "./dist/step-forge.js",
   "type": "module",
   "exports": {
     ".": {
-      "import": "./dist/step-forge.js"
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/step-forge.cjs"
+      },
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/step-forge.js"
+      }
     },
     "./analyzer": {
+      "types": "./dist/analyzer.d.ts",
       "import": "./dist/analyzer.js"
     },
     "./dist/": {
@@ -19,7 +27,7 @@
   },
   "types": "./dist/index.d.ts",
   "scripts": {
-    "build": "rm -rf build && tsc && rolldown -c && dts-bundle-generator --config ./dts-bundle-generator.config.cjs && cp package.json build/",
+    "build": "rm -rf build && tsc && rolldown -c && dts-bundle-generator --config ./dts-bundle-generator.config.cjs && cp build/dist/index.d.ts build/dist/index.d.cts && cp package.json build/",
     "test:cucumber": "NODE_ENV=test NODE_OPTIONS='--import tsx' cucumber-js -p default",
     "test:ci": "NODE_ENV=test NODE_OPTIONS='--import tsx' cucumber-js -p ci",
     "test": "NODE_ENV=test PORT=7888 LOG_LEVEL=none NODE_OPTIONS='--import tsx' cucumber-js -p all 2> /dev/null",

package/rolldown.config.mjs

@@ -1,5 +1,15 @@
 import { defineConfig } from "rolldown";
 
+const allExternal = [
+  "@cucumber/cucumber",
+  "@cucumber/gherkin",
+  "@cucumber/messages",
+  "@cucumber/cucumber-expressions",
+  "lodash",
+  "typescript",
+  /^node:/,
+];
+
 export default defineConfig([
   {
     input: "./src/index.ts",
@@ -8,7 +18,16 @@ export default defineConfig([
       format: "esm",
       sourcemap: true,
     },
-    external: ["@cucumber/cucumber", "lodash"],
+    external: allExternal,
+  },
+  {
+    input: "./src/index.ts",
+    output: {
+      file: "./build/dist/step-forge.cjs",
+      format: "cjs",
+      sourcemap: true,
+    },
+    external: allExternal,
   },
   {
     input: {
@@ -21,14 +40,6 @@ export default defineConfig([
       sourcemap: true,
       entryFileNames: "[name].js",
     },
-    external: [
-      "@cucumber/cucumber",
-      "@cucumber/gherkin",
-      "@cucumber/messages",
-      "@cucumber/cucumber-expressions",
-      "lodash",
-      "typescript",
-      /^node:/,
-    ],
+    external: allExternal,
   },
 ]);

package/src/analyzer/gherkinParser.ts

@@ -17,7 +17,7 @@ export function parseFeatureFiles(filePaths: string[]): ParsedScenario[] {
   return scenarios;
 }
 
-function parseFeatureContent(
+export function parseFeatureContent(
   content: string,
   filePath: string
 ): ParsedScenario[] {

package/src/analyzer/index.ts

@@ -1,8 +1,11 @@
 import { glob } from "node:fs/promises";
 import * as path from "node:path";
 import { extractStepDefinitions } from "./stepExtractor.js";
-import { parseFeatureFiles } from "./gherkinParser.js";
-import { matchScenarioSteps } from "./stepMatcher.js";
+import { parseFeatureFiles, parseFeatureContent } from "./gherkinParser.js";
+import {
+  matchScenarioSteps,
+  findMatchingDefinitions,
+} from "./stepMatcher.js";
 import { defaultRules, runRules } from "./rules/index.js";
 import type {
   AnalyzerConfig,
@@ -24,6 +27,15 @@ export type {
   ParsedStep,
 };
 
+export {
+  extractStepDefinitions,
+  parseFeatureFiles,
+  parseFeatureContent,
+  matchScenarioSteps,
+  findMatchingDefinitions,
+  defaultRules,
+};
+
 export interface AnalyzeOptions {
   rules?: AnalysisRule[];
 }

package/src/analyzer/rules/dependencyRule.ts

@@ -24,30 +24,42 @@ export const dependencyRule: AnalysisRule = {
 
       const { dependencies, produces, stepType } = step.definitions[0];
 
-      // Check required dependencies
+      // Collect all missing required dependencies for this step
+      const missing: Record<string, string[]> = {};
       for (const phase of ["given", "when", "then"] as const) {
         for (const [key, requirement] of Object.entries(dependencies[phase])) {
           if (requirement === "required" && !produced[phase].has(key)) {
-            const available = [...produced[phase]];
-            const availableStr =
-              available.length > 0 ? available.join(", ") : "(none)";
-            diagnostics.push({
-              file: scenario.file,
-              range: {
-                startLine: step.line,
-                startColumn: step.column,
-                endLine: step.line,
-                endColumn: step.column + step.text.length,
-              },
-              severity: "error",
-              message: `Step "${step.text}" requires '${phase}.${key}' but no preceding step produces it. Available ${phase} keys: ${availableStr}. Defined in: ${step.definitions[0].sourceFile}:${step.definitions[0].line}`,
-              rule: "dependency-check",
-              source: "step-forge",
-            });
+            if (!missing[phase]) {
+              missing[phase] = [];
+            }
+            missing[phase].push(key);
           }
         }
       }
 
+      if (Object.keys(missing).length > 0) {
+        const lines = Object.entries(missing).map(
+          ([phase, keys]) =>
+            `${phase.charAt(0).toUpperCase() + phase.slice(1)}: ${keys.map((k) => `${phase}.${k}`).join(", ")}`
+        );
+        const message =
+          "Missing required dependencies:\n" + lines.join("\n");
+
+        diagnostics.push({
+          file: scenario.file,
+          range: {
+            startLine: step.line,
+            startColumn: step.column,
+            endLine: step.line,
+            endColumn: step.column + step.text.length,
+          },
+          severity: "error",
+          message,
+          rule: "dependency-check",
+          source: "step-forge",
+        });
+      }
+
       // Add produced keys for this step
       for (const key of produces) {
         produced[stepType].add(key);

package/src/analyzer/stepMatcher.ts

@@ -1,29 +1,40 @@
-import {
-  CucumberExpression,
-  ParameterTypeRegistry,
-} from "@cucumber/cucumber-expressions";
 import { MatchedStep, ParsedScenario, StepDefinitionMeta } from "./types.js";
 
-interface CompiledExpression {
-  expression: CucumberExpression;
+interface CompiledPattern {
+  regex: RegExp;
   definition: StepDefinitionMeta;
 }
 
-export function matchScenarioSteps(
-  scenario: ParsedScenario,
+function compileDefinitions(
   definitions: StepDefinitionMeta[]
-): MatchedStep[] {
-  const registry = new ParameterTypeRegistry();
-
-  const compiled: CompiledExpression[] = [];
+): CompiledPattern[] {
+  const compiled: CompiledPattern[] = [];
   for (const def of definitions) {
     try {
-      const expression = new CucumberExpression(def.expression, registry);
-      compiled.push({ expression, definition: def });
+      // Replace {paramType} placeholders with (.+) to match any value,
+      // matching the Step Forge runtime behavior where all params use {string}
+      // and values are coerced at runtime via typeCoercer.
+      const placeholder = "###PLACEHOLDER###";
+      const regexStr = def.expression
+        .replace(/\{[^}]+\}/g, placeholder)
+        .replace(/[.*+?^$()|[\]\\]/g, "\\$&")
+        .replace(new RegExp(placeholder, "g"), "(.+)");
+      compiled.push({
+        regex: new RegExp(`^${regexStr}$`, "i"),
+        definition: def,
+      });
     } catch {
       // Skip definitions with invalid expressions
     }
   }
+  return compiled;
+}
+
+export function matchScenarioSteps(
+  scenario: ParsedScenario,
+  definitions: StepDefinitionMeta[]
+): MatchedStep[] {
+  const compiled = compileDefinitions(definitions);
 
   return scenario.steps.map((step) => {
     const matches = findMatches(step.text, step.effectiveKeyword, compiled);
@@ -34,10 +45,19 @@ export function matchScenarioSteps(
   });
 }
 
+export function findMatchingDefinitions(
+  text: string,
+  effectiveKeyword: "Given" | "When" | "Then",
+  definitions: StepDefinitionMeta[]
+): StepDefinitionMeta[] {
+  const compiled = compileDefinitions(definitions);
+  return findMatches(text, effectiveKeyword, compiled);
+}
+
 function findMatches(
   text: string,
   effectiveKeyword: "Given" | "When" | "Then",
-  compiled: CompiledExpression[]
+  compiled: CompiledPattern[]
 ): StepDefinitionMeta[] {
   const keywordToStepType: Record<string, string> = {
     Given: "given",
@@ -48,19 +68,17 @@ function findMatches(
 
   // First try to match with the correct step type
   const typedMatches: StepDefinitionMeta[] = [];
-  for (const { expression, definition } of compiled) {
+  for (const { regex, definition } of compiled) {
     if (definition.stepType !== expectedStepType) continue;
-    const result = expression.match(text);
-    if (result) typedMatches.push(definition);
+    if (regex.test(text)) typedMatches.push(definition);
   }
 
   if (typedMatches.length > 0) return typedMatches;
 
-  // Fallback: match any step type (Cucumber itself doesn't enforce keyword-to-step-type)
+  // Fallback: match any step type
   const fallbackMatches: StepDefinitionMeta[] = [];
-  for (const { expression, definition } of compiled) {
-    const result = expression.match(text);
-    if (result) fallbackMatches.push(definition);
+  for (const { regex, definition } of compiled) {
+    if (regex.test(text)) fallbackMatches.push(definition);
   }
 
   return fallbackMatches;

package/src/index.ts

@@ -2,5 +2,45 @@ import { givenBuilder } from "./given";
 import { whenBuilder } from "./when";
 import { thenBuilder } from "./then";
 import { BasicWorld } from "./world";
+import {
+  analyze,
+  extractStepDefinitions,
+  parseFeatureFiles,
+  parseFeatureContent,
+  matchScenarioSteps,
+  findMatchingDefinitions,
+  defaultRules,
+} from "./analyzer/index";
+import type {
+  AnalyzerConfig,
+  AnalyzeOptions,
+  AnalysisRule,
+  Diagnostic,
+  StepDefinitionMeta,
+  ParsedScenario,
+  ParsedStep,
+  MatchedStep,
+} from "./analyzer/index";
 
 export { givenBuilder, whenBuilder, thenBuilder, BasicWorld };
+
+export const analyzer = {
+  analyze,
+  extractStepDefinitions,
+  parseFeatureFiles,
+  parseFeatureContent,
+  matchScenarioSteps,
+  findMatchingDefinitions,
+  defaultRules,
+};
+
+export type {
+  AnalyzerConfig,
+  AnalyzeOptions,
+  AnalysisRule,
+  Diagnostic,
+  StepDefinitionMeta,
+  ParsedScenario,
+  ParsedStep,
+  MatchedStep,
+};