@aisdlc/core 2.3.0 → 2.4.0

package/dist/index.cjs

@@ -294,19 +294,26 @@ function extractPythonFunctions(content, filePath) {
   }
   return buildMetricsFromBlocks(blocks, content, filePath);
 }
-function processBraceLine(line, state, blocks, lineIndex, ext) {
-  if (!state.currentFn) {
-    const candidate = matchFunctionHeader(line, ext);
-    if (!candidate) return;
+function tryStartBraceFunction(line, state, ext) {
+  if (state.currentFn || state.inBlockComment || state.rawTerm) return;
+  const candidate = matchFunctionHeader(line, ext);
+  if (candidate) {
     state.currentFn = candidate;
     state.braceCount = 0;
     state.fnLines = [];
   }
-  state.fnLines.push(line);
-  const res = scanBracesInLine(line, state.inBlockComment, ext);
+}
+function updateBraceScanState(line, state, ext) {
+  const res = scanBracesInLine(line, state.inBlockComment, state.rawTerm, ext);
   state.inBlockComment = res.nowInBlock;
+  state.rawTerm = res.nowRawTerm;
   state.braceCount += res.delta;
-  if (state.braceCount === 0 && state.fnLines.length > 1) {
+}
+function processBraceLine(line, state, blocks, lineIndex, ext) {
+  tryStartBraceFunction(line, state, ext);
+  if (state.currentFn) state.fnLines.push(line);
+  updateBraceScanState(line, state, ext);
+  if (state.currentFn && state.braceCount === 0 && state.fnLines.length > 1) {
     blocks.push({ name: state.currentFn, body: state.fnLines.join("\n"), startLine: lineIndex });
     state.currentFn = null;
     state.fnLines = [];
@@ -316,98 +323,153 @@ function extractBraceFunctions(content, filePath) {
   const ext = path4__namespace.extname(filePath).toLowerCase();
   const lines = content.split("\n");
   const blocks = [];
-  const state = { currentFn: null, braceCount: 0, fnLines: [], inBlockComment: false };
+  const state = {
+    currentFn: null,
+    braceCount: 0,
+    fnLines: [],
+    inBlockComment: false,
+    rawTerm: null
+  };
   for (let i = 0; i < lines.length; i++) {
     processBraceLine(lines[i], state, blocks, i, ext);
   }
   return buildMetricsFromBlocks(blocks, content, filePath);
 }
+var HEADER_EXCLUSIONS = /* @__PURE__ */ new Set([
+  "if",
+  "for",
+  "foreach",
+  "while",
+  "switch",
+  "catch",
+  "select",
+  "match",
+  "class",
+  "struct",
+  "interface",
+  "record",
+  "enum",
+  "namespace",
+  "using",
+  "lock",
+  "fixed",
+  "synchronized",
+  "try",
+  "else"
+]);
 function matchCStyleHeader(line) {
   const match = line.match(
-    /(?:(?:public|private|protected|static|async|virtual|override|fn)\s+)*(?:function\s+([a-zA-Z0-9_$]+)|(?:[a-zA-Z0-9_<>[\]?]+\s+)+([a-zA-Z0-9_$]+)\s*\([^;{]*\)\s*(?:throws\s+[^{]+)?\{|([a-zA-Z0-9_$]+)\s*\([^;{]*\)\s*(?::\s*[^{]+\s*)?\{)/
+    /(?:(?:public|private|protected|internal|static|async|virtual|override|sealed|abstract|final|synchronized|default|fn)\s+)*(?:function\s+([a-zA-Z0-9_$]+)|(?:[a-zA-Z0-9_<>[\]?,.\s]+\s+)+([a-zA-Z0-9_$]+)\s*(?:<[^>]+>)?\s*\([^;{}]*\)\s*(?:where\s+[^{]+|throws\s+[^{]+)?\{|([a-zA-Z0-9_$]+)\s*\([^;{}]*\)\s*(?::\s*[^{]+\s*)?\{)/
   );
   if (!match) return null;
   const candidate = match[1] || match[2] || match[3];
-  const exclusions = ["if", "for", "while", "switch", "catch", "select", "match", "class", "struct"];
-  return candidate && !exclusions.includes(candidate) ? candidate : null;
+  return candidate && !HEADER_EXCLUSIONS.has(candidate) ? candidate : null;
 }
 function matchFunctionHeader(line, ext) {
   const trimmed = line.trim();
-  if (trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*")) return null;
+  if (trimmed.startsWith("//") || trimmed.startsWith("/*") || trimmed.startsWith("*") || trimmed.startsWith("#")) {
+    return null;
+  }
   if (ext === ".go") {
-    const match = line.match(/func\s+(?:\([^)]*\)\s*)?([a-zA-Z0-9_$]+)\s*\(/);
+    const match = line.match(/func\s+(?:\([^)]*\)\s*)?([a-zA-Z0-9_$]+)\s*(?:\[[^\]]*\])?\s*\(/);
     return match ? match[1] : null;
   }
   if (ext === ".rs") {
-    const match = line.match(/(?:pub\s+)?(?:async\s+)?(?:unsafe\s+)?fn\s+([a-zA-Z0-9_$]+)\s*\(/);
+    const match = line.match(/(?:pub(?:\([^)]*\))?\s+)?(?:async\s+)?(?:unsafe\s+)?(?:const\s+)?fn\s+([a-zA-Z0-9_$]+)\s*(?:<[^>]*>)?\s*\(/);
     return match ? match[1] : null;
   }
   return matchCStyleHeader(line);
 }
-function handleStringChar(char, inString) {
-  if (char === inString) return { inString: null, skip: false };
-  return { inString, skip: char === "\\" };
-}
-function handleBlockState(char, next, inBlock) {
-  if (inBlock && char === "*" && next === "/") return { inBlock: false, skip: true };
-  return { inBlock, skip: false };
-}
-function checkCommentOrQuote(char, next, ext) {
-  if (char === "/" && next === "/") return { startBlock: false, quote: null, isLineComment: true };
-  if (char === "/" && next === "*") return { startBlock: true, quote: null, isLineComment: false };
-  const isQuote = char === '"' || char === "'" || char === "`" && ext === ".go";
-  return { startBlock: false, quote: isQuote ? char : null, isLineComment: false };
-}
-function stepSkippedState(char, next, inBlock, inString) {
-  if (inBlock) {
-    const res = handleBlockState(char, next, inBlock);
-    return { inBlock: res.inBlock, inString, skip: res.skip, handled: true };
-  }
-  if (inString) {
-    const res = handleStringChar(char, inString);
-    return { inBlock, inString: res.inString, skip: res.skip, handled: true };
-  }
-  return { inBlock, inString, skip: false, handled: false };
-}
-function checkCodeChar(char, next, ext) {
-  const trigger = checkCommentOrQuote(char, next, ext);
-  if (trigger.isLineComment) return { delta: 0, startBlock: false, quote: null, stop: true };
-  if (trigger.startBlock) return { delta: 0, startBlock: true, quote: null, stop: false };
-  if (trigger.quote) return { delta: 0, startBlock: false, quote: trigger.quote, stop: false };
-  const delta = char === "{" ? 1 : char === "}" ? -1 : 0;
-  return { delta, startBlock: false, quote: null, stop: false };
-}
-function applyCodeChar(res, state) {
-  if (res.stop) return { advance: 0, stop: true };
-  if (res.startBlock) {
+function detectRustOrGoRawString(sub, ext) {
+  if (ext === ".rs") {
+    const m = sub.match(/^r(#*)"/);
+    return m ? { term: `"${m[1]}`, advance: m[0].length - 1 } : null;
+  }
+  if (ext === ".go" && sub.startsWith("`")) {
+    return { term: "`", advance: 0 };
+  }
+  return null;
+}
+function detectCsJavaOrCppRawString(sub, ext) {
+  if (ext === ".cs" || ext === ".java") {
+    const m = sub.match(/^\$*("{3,})/);
+    if (m) return { term: m[1], advance: m[0].length - 1 };
+    const v = ext === ".cs" ? sub.match(/^(@\$|\$@|@)"/) : null;
+    return v ? { term: '"', advance: v[0].length - 1 } : null;
+  }
+  const cpp = sub.match(/^R"([a-zA-Z0-9_]*)\(/);
+  return cpp ? { term: `)${cpp[1]}"`, advance: cpp[0].length - 1 } : null;
+}
+function detectRawStringOpen(line, index, ext) {
+  const sub = line.slice(index);
+  return detectRustOrGoRawString(sub, ext) || detectCsJavaOrCppRawString(sub, ext);
+}
+function consumeRawOrBlock(line, index, state) {
+  if (state.inBlock) {
+    if (line[index] === "*" && line[index + 1] === "/") {
+      state.inBlock = false;
+      return { advance: 1, handled: true };
+    }
+    return { advance: 0, handled: true };
+  }
+  if (state.rawTerm) {
+    if (line.startsWith(state.rawTerm, index)) {
+      const len = state.rawTerm.length - 1;
+      state.rawTerm = null;
+      return { advance: len, handled: true };
+    }
+    return { advance: 0, handled: true };
+  }
+  return { advance: 0, handled: false };
+}
+function consumeNormalQuote(line, index, state) {
+  if (!state.inString) return { advance: 0, handled: false };
+  const ch = line[index];
+  if (ch === "\\") return { advance: 1, handled: true };
+  if (ch === state.inString) state.inString = null;
+  return { advance: 0, handled: true };
+}
+function applyQuoteOrBrace(ch, state) {
+  if (ch === '"' || ch === "'") {
+    state.inString = ch;
+    return;
+  }
+  if (ch === "{") state.delta++;
+  if (ch === "}") state.delta--;
+}
+function stepActiveCodeToken(line, j, ext, state) {
+  const pair = line.slice(j, j + 2);
+  if (pair === "//") return { advance: 0, stop: true };
+  if (pair === "/*") {
     state.inBlock = true;
     return { advance: 1, stop: false };
   }
-  if (res.quote) {
-    state.inString = res.quote;
-    return { advance: 0, stop: false };
+  const rawOpen = detectRawStringOpen(line, j, ext);
+  if (rawOpen) {
+    state.rawTerm = rawOpen.term;
+    return { advance: rawOpen.advance, stop: false };
   }
-  state.delta += res.delta;
+  applyQuoteOrBrace(line[j], state);
   return { advance: 0, stop: false };
 }
-function scanBracesInLine(line, wasInBlock, ext) {
-  const state = { delta: 0, inBlock: wasInBlock, inString: null };
+function scanBracesInLine(line, wasInBlock, wasRawTerm, ext) {
+  const state = { delta: 0, inBlock: wasInBlock, rawTerm: wasRawTerm, inString: null };
   for (let j = 0; j < line.length; j++) {
-    const char = line[j];
-    const next = j + 1 < line.length ? line[j + 1] : "";
-    const skipped = stepSkippedState(char, next, state.inBlock, state.inString);
-    if (skipped.handled) {
-      state.inBlock = skipped.inBlock;
-      state.inString = skipped.inString;
-      if (skipped.skip) j++;
+    const rawOrBlock = consumeRawOrBlock(line, j, state);
+    if (rawOrBlock.handled) {
+      j += rawOrBlock.advance;
       continue;
     }
-    const res = checkCodeChar(char, next, ext);
-    const step = applyCodeChar(res, state);
-    if (step.stop) break;
-    j += step.advance;
+    const quoteStep = consumeNormalQuote(line, j, state);
+    if (quoteStep.handled) {
+      j += quoteStep.advance;
+      continue;
+    }
+    const codeStep = stepActiveCodeToken(line, j, ext, state);
+    if (codeStep.stop) break;
+    j += codeStep.advance;
   }
-  return { delta: state.delta, nowInBlock: state.inBlock };
+  return { delta: state.delta, nowInBlock: state.inBlock, nowRawTerm: state.rawTerm };
 }
 function buildMetricsFromBlocks(blocks, content, filePath) {
   if (blocks.length === 0) {
@@ -431,11 +493,20 @@ function buildMetricsFromBlocks(blocks, content, filePath) {
 }
 function detectPolyglotSmells(body) {
   const smells = [];
-  if (/#\s*noqa|#\s*type:\s*ignore|@SuppressWarnings/.test(body)) {
+  if (/#\s*noqa|#\s*type:\s*ignore|@SuppressWarnings|#pragma\s+warning\s+disable/.test(body)) {
     smells.push("Supresi\xF3n no autorizada de linter");
   }
   return smells;
 }
+function stripStringsAndComments(body, ext) {
+  let cleaned = body;
+  if (ext === ".py") {
+    cleaned = cleaned.replace(/"""[\s\S]*?"""|'''[\s\S]*?'''/g, '""').replace(/#.*/g, "");
+  } else {
+    cleaned = cleaned.replace(/\/\*[\s\S]*?\*\/|\/\/.*/g, "").replace(/r(#+)"[\s\S]*?"\1/g, '""').replace(/R"([a-zA-Z0-9_]*)\([\s\S]*?\)\1"/g, '""').replace(/\$*"{3,}[\s\S]*?"{3,}/g, '""').replace(/`[\s\S]*?`/g, '""');
+  }
+  return cleaned.replace(/"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/g, '""');
+}
 function computeHalsteadMI(body, cyclomatic, loc, commentCount) {
   const cleanText = body.replace(/\/\*[\s\S]*?\*\/|\/\/.*|#.*/g, "");
   const tokens = cleanText.split(/[\s,;().{}[\]=+\-*/<>!&|:]+/).filter((t) => t.length > 0);
@@ -460,9 +531,11 @@ function countCommentsAndLoc(rawLines, isPy) {
 function calculatePolyglotMetrics(body, name, filePath, startLine) {
   const ext = path4__namespace.extname(filePath).toLowerCase();
   const rawLines = body.split(/\r?\n/).map((l) => l.trim()).filter((l) => l.length > 0);
-  const { loc, commentCount, cleanLines } = countCommentsAndLoc(rawLines, ext === ".py");
-  const cyclomatic = computePolyglotCyclomatic(body, ext);
-  const cognitive = computePolyglotCognitive(cleanLines, ext === ".py");
+  const { loc, commentCount } = countCommentsAndLoc(rawLines, ext === ".py");
+  const strippedBody = stripStringsAndComments(body, ext);
+  const strippedLines = strippedBody.split(/\r?\n/).filter((l) => l.trim().length > 0);
+  const cyclomatic = computePolyglotCyclomatic(strippedBody, ext);
+  const cognitive = computePolyglotCognitive(strippedLines, ext === ".py");
   const maintainability = computeHalsteadMI(body, cyclomatic, loc, commentCount);
   return {
     functionName: name,
@@ -475,40 +548,60 @@ function calculatePolyglotMetrics(body, name, filePath, startLine) {
     line: startLine ? startLine + 1 : 1
   };
 }
-function computePolyglotCyclomatic(body, ext) {
-  let regex;
+function getCyclomaticPattern(ext) {
   if (ext === ".py") {
-    regex = /\b(if|elif|for|while|except)\b|\b(and|or)\b/g;
-  } else if (ext === ".go") {
-    regex = /\b(if|for|case|select)\b|&&|\|\|/g;
-  } else if (ext === ".rs") {
-    regex = /\b(if|for|while|match)\b|&&|\|\||\?/g;
-  } else {
-    regex = /\b(if|else\s+if|for|while|catch|case)\b|\?|&&|\|\|/g;
+    return /\b(if|elif|for|while|except|case)\b|\b(and|or)\b/g;
+  }
+  if (ext === ".go") {
+    return /\b(if|for|case|select)\b|&&|\|\|/g;
+  }
+  if (ext === ".rs") {
+    return /\b(if|for|while|match)\b|&&|\|\||\?/g;
+  }
+  if (ext === ".cs") {
+    return /\b(if|else\s+if|for|foreach|while|catch|case|when)\b|\?\?|\?\.(?=[a-zA-Z_])|&&|\|\|/g;
   }
-  const cleanBody = body.replace(/"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/g, "");
-  const matches = cleanBody.match(regex);
+  if (ext === ".java") {
+    return /\b(if|else\s+if|for|while|catch|case|when)\b|&&|\|\|/g;
+  }
+  return /\b(if|else\s+if|for|while|catch|case)\b|\?|&&|\|\|/g;
+}
+function computePolyglotCyclomatic(strippedBody, ext) {
+  const regex = getCyclomaticPattern(ext);
+  const matches = strippedBody.match(regex);
   return 1 + (matches ? matches.length : 0);
 }
-function computePolyglotCognitive(lines, isPy) {
+var PY_COGNITIVE_RE = /\b(if|elif|for|while|except|match)\b/;
+var BRACE_COGNITIVE_RE = /\b(if|for|foreach|while|catch|match|select|switch)\b/;
+function computePythonCognitive(lines) {
+  let cognitive = 0;
+  const baseIndent = lines.length > 0 ? lines[0].length - lines[0].trimStart().length : 0;
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (PY_COGNITIVE_RE.test(line)) {
+      const relIndent = Math.max(0, line.length - line.trimStart().length - baseIndent - 4);
+      cognitive += 1 + Math.floor(relIndent / 4);
+    }
+  }
+  return cognitive;
+}
+function computeBraceCognitive(lines) {
   let cognitive = 0;
   let nesting = 0;
-  for (const line of lines) {
-    if (isPy) {
-      const indent = line.length - line.trimStart().length;
-      if (/\b(if|elif|for|while|except)\b/.test(line)) {
-        cognitive += 1 + Math.floor(indent / 4);
-      }
-    } else {
-      if (line.includes("{")) nesting++;
-      if (line.includes("}")) nesting = Math.max(0, nesting - 1);
-      if (/\b(if|for|while|catch|match|select)\b/.test(line)) {
-        cognitive += 1 + nesting;
-      }
+  for (let i = 1; i < lines.length; i++) {
+    const line = lines[i];
+    if (BRACE_COGNITIVE_RE.test(line)) {
+      cognitive += 1 + nesting;
     }
+    const opens = (line.match(/\{/g) || []).length;
+    const closes = (line.match(/\}/g) || []).length;
+    nesting = Math.max(0, nesting + opens - closes);
   }
   return cognitive;
 }
+function computePolyglotCognitive(lines, isPy) {
+  return isPy ? computePythonCognitive(lines) : computeBraceCognitive(lines);
+}
 function walkMdFiles(dir, fileList = [], excludeDirs = [
   "node_modules",
   ".git",
@@ -1092,9 +1185,54 @@ function collectTestCorpus(rootDir, allMdFiles) {
   }
   return { gherkinSources, combinedTests: testContents.join("\n") };
 }
-function assembleCoverageResult(reqAudit, taskAudit, useCaseFlows, reqErrors, taskErrors, ucErrors) {
+function isCucumberScenarioPassed(element) {
+  const steps = Array.isArray(element.steps) ? element.steps : [];
+  if (steps.length === 0) return false;
+  return steps.every((s) => {
+    const res = s.result;
+    return res && res.status === "passed";
+  });
+}
+function countCucumberScenarios(raw) {
+  let passed = 0;
+  let failed = 0;
+  for (const feat of raw) {
+    const elements = Array.isArray(feat.elements) ? feat.elements : [];
+    for (const el of elements) {
+      if (isCucumberScenarioPassed(el)) passed++;
+      else failed++;
+    }
+  }
+  return { passed, failed };
+}
+function parseCucumberReportFile(reportPath) {
+  if (!fs7__namespace.existsSync(reportPath)) return void 0;
+  try {
+    const raw = JSON.parse(fs7__namespace.readFileSync(reportPath, "utf-8"));
+    if (!Array.isArray(raw)) return void 0;
+    const { passed, failed } = countCucumberScenarios(raw);
+    return {
+      evaluatedFeatures: raw.length,
+      passedScenarios: passed,
+      failedScenarios: failed,
+      passed: passed + failed > 0 && failed === 0
+    };
+  } catch {
+    return void 0;
+  }
+}
+function resolveCucumberReport(rootDir, options) {
+  const candidate = options.cucumberReportPath ? path4__namespace.isAbsolute(options.cucumberReportPath) ? options.cucumberReportPath : path4__namespace.join(rootDir, options.cucumberReportPath) : path4__namespace.join(rootDir, "reports", "cucumber-report.json");
+  const parsed = parseCucumberReportFile(candidate);
+  if (parsed) return parsed;
+  if (options.enforceCucumberExecution) {
+    return { evaluatedFeatures: 0, passedScenarios: 0, failedScenarios: 1, passed: false };
+  }
+  return void 0;
+}
+function assembleCoverageResult(reqAudit, taskAudit, useCaseFlows, reqErrors, taskErrors, ucErrors, rootDir, options) {
   return {
-    success: reqErrors === 0 && taskErrors === 0 && ucErrors === 0,
+    success: reqErrors === 0 && taskErrors === 0 && ucErrors === 0 && (!resolveCucumberReport(rootDir, options) || resolveCucumberReport(rootDir, options).passed),
     totalRequirements: reqAudit.length,
     passedRequirements: reqAudit.length - reqErrors,
     failedRequirements: reqErrors,
@@ -1105,6 +1243,7 @@ function assembleCoverageResult(reqAudit, taskAudit, useCaseFlows, reqErrors, ta
     tasks: taskAudit,
     useCaseFlows,
     failedUseCaseFlows: ucErrors,
+    ...resolveCucumberReport(rootDir, options) ? { cucumberExecution: resolveCucumberReport(rootDir, options) } : {},
     reportMarkdown: generateTestingCoverageReportMarkdown(reqAudit, taskAudit, reqErrors, taskErrors)
   };
 }
@@ -1156,7 +1295,9 @@ function verifyTestingCoverage(options = {}) {
     state.useCaseFlows,
     state.reqErrors,
     state.taskErrors,
-    state.ucErrors
+    state.ucErrors,
+    rootDir,
+    options
   );
 }
 
@@ -5532,6 +5673,277 @@ function verifyTasksGovernance(options = {}) {
   );
   return assembleGovernanceResult(data, reportMarkdown);
 }
+var BddStepRegistry = class {
+  definitions = [];
+  register(pattern, handler) {
+    this.definitions.push({ pattern, handler });
+    return this;
+  }
+  given(pattern, handler) {
+    return this.register(pattern, handler);
+  }
+  when(pattern, handler) {
+    return this.register(pattern, handler);
+  }
+  then(pattern, handler) {
+    return this.register(pattern, handler);
+  }
+  getDefinitions() {
+    return this.definitions;
+  }
+};
+var STEP_PREFIX_RE = /^(Given|When|Then|And|But|Dado|Cuando|Entonces|Y|Pero)\s+(.+)$/i;
+var SCENARIO_HEADER_RE = /^(Scenario|Escenario|Scenario Outline|Esquema del escenario):\s*(.+)$/i;
+function parseTableRowCells(line) {
+  return line.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((c) => c.trim());
+}
+function attachStepTableRow(lastStep, cells) {
+  if (!lastStep || cells.length < 2) return;
+  if (!lastStep.table) lastStep.table = {};
+  lastStep.table[cells[0]] = cells[1];
+}
+function attachExampleRow(scenario, headers, cells) {
+  if (!scenario) return headers;
+  if (headers.length === 0) return cells;
+  const row = {};
+  for (let i = 0; i < headers.length; i++) {
+    row[headers[i]] = cells[i] ?? "";
+  }
+  scenario.examples.push(row);
+  return headers;
+}
+function createInitialParseState() {
+  return {
+    featureName: "Unnamed Feature",
+    featureTags: [],
+    pendingTags: [],
+    backgroundSteps: [],
+    scenarios: [],
+    currentScenario: null,
+    inBackground: false,
+    inExamples: false,
+    exampleHeaders: []
+  };
+}
+function handleStructuralHeaderLine(line, state) {
+  if (/^(Feature|Caracter[ií]stica):/i.test(line)) {
+    state.featureName = line.replace(/^(Feature|Caracter[ií]stica):\s*/i, "").trim();
+    state.featureTags.push(...state.pendingTags);
+    state.pendingTags = [];
+    return true;
+  }
+  if (/^(Background|Antecedentes):/i.test(line)) {
+    state.inBackground = true;
+    state.inExamples = false;
+    state.currentScenario = null;
+    return true;
+  }
+  if (/^(Examples|Ejemplos):/i.test(line)) {
+    state.inExamples = true;
+    state.exampleHeaders = [];
+    return true;
+  }
+  return false;
+}
+function startScenarioBlock(scenMatch, state) {
+  state.inBackground = false;
+  state.inExamples = false;
+  const block = {
+    name: scenMatch[2].trim(),
+    tags: [...state.featureTags, ...state.pendingTags],
+    isOutline: /outline|esquema/i.test(scenMatch[1]),
+    steps: [],
+    examples: []
+  };
+  state.pendingTags = [];
+  state.scenarios.push(block);
+  state.currentScenario = block;
+}
+function appendParsedStep(stepMatch, state) {
+  const step = { keyword: stepMatch[1], text: stepMatch[2].trim() };
+  if (state.inBackground) {
+    state.backgroundSteps.push(step);
+  } else if (state.currentScenario) {
+    state.currentScenario.steps.push(step);
+  }
+}
+function handleScenarioOrStepLine(line, state) {
+  const scenMatch = line.match(SCENARIO_HEADER_RE);
+  if (scenMatch) {
+    startScenarioBlock(scenMatch, state);
+    return;
+  }
+  const stepMatch = line.match(STEP_PREFIX_RE);
+  if (stepMatch) {
+    appendParsedStep(stepMatch, state);
+  }
+}
+function processFeatureLine(rawLine, state) {
+  const line = rawLine.trim();
+  if (!line || line.startsWith("#")) return;
+  if (line.startsWith("@")) {
+    const tags = line.split(/\s+/).filter((t) => t.startsWith("@"));
+    state.pendingTags.push(...tags);
+    return;
+  }
+  if (line.startsWith("|")) {
+    const cells = parseTableRowCells(line);
+    if (state.inExamples) {
+      state.exampleHeaders = attachExampleRow(state.currentScenario, state.exampleHeaders, cells);
+    } else {
+      const targetList = state.inBackground ? state.backgroundSteps : state.currentScenario?.steps || [];
+      attachStepTableRow(targetList[targetList.length - 1], cells);
+    }
+    return;
+  }
+  if (!handleStructuralHeaderLine(line, state)) {
+    handleScenarioOrStepLine(line, state);
+  }
+}
+function parseFeatureDocument(content) {
+  const state = createInitialParseState();
+  for (const rawLine of content.split(/\r?\n/)) {
+    processFeatureLine(rawLine, state);
+  }
+  return {
+    featureName: state.featureName,
+    tags: state.featureTags,
+    backgroundSteps: state.backgroundSteps,
+    scenarios: state.scenarios
+  };
+}
+function interpolatePlaceholders(text, row) {
+  let out = text;
+  for (const [k, v] of Object.entries(row)) {
+    out = out.replace(new RegExp(`<${k}>`, "g"), v);
+  }
+  return out;
+}
+function expandScenarioOutlines(scenarios) {
+  const expanded = [];
+  for (const sc of scenarios) {
+    if (!sc.isOutline || sc.examples.length === 0) {
+      expanded.push(sc);
+      continue;
+    }
+    sc.examples.forEach((row, idx) => {
+      expanded.push({
+        name: `${sc.name} (Example #${idx + 1})`,
+        tags: sc.tags,
+        isOutline: false,
+        steps: sc.steps.map((st) => ({
+          keyword: st.keyword,
+          text: interpolatePlaceholders(st.text, row),
+          table: st.table
+        })),
+        examples: []
+      });
+    });
+  }
+  return expanded;
+}
+function matchStepDefinition(text, definitions) {
+  for (const entry of definitions) {
+    if (typeof entry.pattern === "string") {
+      if (entry.pattern === text) return { entry, args: [] };
+    } else {
+      const m = text.match(entry.pattern);
+      if (m) return { entry, args: m.slice(1) };
+    }
+  }
+  return null;
+}
+async function executeSingleStep(step, definitions) {
+  const matched = matchStepDefinition(step.text, definitions);
+  if (!matched) {
+    return { keyword: step.keyword, text: step.text, status: "undefined", durationMs: 0 };
+  }
+  const start = Date.now();
+  try {
+    await matched.entry.handler(matched.args, step.table);
+    return { keyword: step.keyword, text: step.text, status: "passed", durationMs: Date.now() - start };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return {
+      keyword: step.keyword,
+      text: step.text,
+      status: "failed",
+      durationMs: Date.now() - start,
+      errorMessage: msg
+    };
+  }
+}
+async function executeScenarioSteps(allSteps, definitions) {
+  const stepResults = [];
+  let status = "passed";
+  for (const step of allSteps) {
+    if (status !== "passed") {
+      stepResults.push({ keyword: step.keyword, text: step.text, status: "skipped", durationMs: 0 });
+      continue;
+    }
+    const res = await executeSingleStep(step, definitions);
+    stepResults.push(res);
+    if (res.status === "failed" || res.status === "undefined") {
+      status = res.status;
+    }
+  }
+  return { stepResults, status };
+}
+async function runAllExpandedScenarios(parsed, definitions) {
+  const expanded = expandScenarioOutlines(parsed.scenarios);
+  const out = [];
+  for (const sc of expanded) {
+    const combinedSteps = [...parsed.backgroundSteps, ...sc.steps];
+    const { stepResults, status } = await executeScenarioSteps(combinedSteps, definitions);
+    out.push({ name: sc.name, tags: sc.tags, status, steps: stepResults });
+  }
+  return out;
+}
+async function executeBddFeature(featurePath, registry, options = {}) {
+  const rootDir = options.rootDir || process.cwd();
+  const fullPath = path4__namespace.isAbsolute(featurePath) ? featurePath : path4__namespace.join(rootDir, featurePath);
+  const parsed = parseFeatureDocument(fs7__namespace.readFileSync(fullPath, "utf-8"));
+  const scenarios = await runAllExpandedScenarios(parsed, registry.getDefinitions());
+  const report = {
+    uri: path4__namespace.relative(rootDir, fullPath).replace(/\\/g, "/"),
+    featureName: parsed.featureName,
+    tags: parsed.tags,
+    scenarios,
+    passed: scenarios.length > 0 && scenarios.every((s) => s.status === "passed")
+  };
+  if (options.writeReportPath) writeCucumberJsonReport([report], options.writeReportPath);
+  return report;
+}
+function mapStepToCucumberJson(st) {
+  return {
+    keyword: `${st.keyword} `,
+    name: st.text,
+    result: {
+      status: st.status,
+      duration: st.durationMs * 1e6,
+      ...st.errorMessage ? { error_message: st.errorMessage } : {}
+    }
+  };
+}
+function mapFeatureToCucumberJson(r) {
+  return {
+    uri: r.uri,
+    name: r.featureName,
+    tags: r.tags.map((t) => ({ name: t })),
+    elements: r.scenarios.map((sc) => ({
+      type: "scenario",
+      name: sc.name,
+      tags: sc.tags.map((t) => ({ name: t })),
+      steps: sc.steps.map(mapStepToCucumberJson)
+    }))
+  };
+}
+function writeCucumberJsonReport(reports, outputPath) {
+  const dir = path4__namespace.dirname(outputPath);
+  if (!fs7__namespace.existsSync(dir)) fs7__namespace.mkdirSync(dir, { recursive: true });
+  const payload = JSON.stringify(reports.map(mapFeatureToCucumberJson), null, 2);
+  fs7__namespace.writeFileSync(outputPath, payload, "utf-8");
+}
 function isToolAvailable(toolName) {
   try {
     const cmd = process.platform === "win32" ? "where" : "which";
@@ -6172,7 +6584,7 @@ function resolveProjectIdentity(options) {
 function buildBomMetadata(name, version) {
   return {
     timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    tools: [{ vendor: "AI-SDLC", name: "@aisdlc/core", version: "2.3.0" }],
+    tools: [{ vendor: "AI-SDLC", name: "@aisdlc/core", version: "2.4.0" }],
     component: { type: "application", name, version }
   };
 }
@@ -16348,6 +16760,7 @@ function sanitizeDlpPayload(payload, policy = createDefaultDlpPolicy()) {
 
 exports.ALL_ARCHITECTURE_TEMPLATES = ALL_ARCHITECTURE_TEMPLATES;
 exports.BRANCH_PATTERNS = BRANCH_PATTERNS;
+exports.BddStepRegistry = BddStepRegistry;
 exports.DEFAULT_DLP_RULES = DEFAULT_DLP_RULES;
 exports.DEFAULT_EXCLUDED_PATTERNS = DEFAULT_EXCLUDED_PATTERNS;
 exports.DEFAULT_EXCLUDES = DEFAULT_EXCLUDES;
@@ -16523,6 +16936,7 @@ exports.emitCiOutput = emitCiOutput;
 exports.evaluateCompoundLicense = evaluateCompoundLicense;
 exports.evaluateSingleDependency = evaluateSingleDependency;
 exports.evaluateVulnerabilityThresholds = evaluateVulnerabilityThresholds;
+exports.executeBddFeature = executeBddFeature;
 exports.extractBaselineEntriesFromResults = extractBaselineEntriesFromResults;
 exports.extractCitations = extractCitations;
 exports.extractCommitKpisFromRange = extractCommitKpisFromRange;
@@ -16588,6 +17002,7 @@ exports.normalizeSpdxLicense = normalizeSpdxLicense;
 exports.normalizeUri = normalizeUri;
 exports.parseCommitTrailers = parseCommitTrailers;
 exports.parseDlpPolicy = parseDlpPolicy;
+exports.parseFeatureDocument = parseFeatureDocument;
 exports.parseFrontmatter = parseFrontmatter;
 exports.parseFrontmatterId = parseFrontmatterId;
 exports.parseGenericDoc = parseGenericDoc;
@@ -16674,6 +17089,7 @@ exports.walkMdFiles = walkMdFiles;
 exports.walkProjectFiles = walkProjectFiles;
 exports.walkSourceFiles = walkSourceFiles;
 exports.walkTaskFiles = walkTaskFiles;
+exports.writeCucumberJsonReport = writeCucumberJsonReport;
 exports.writeCycloneDxSbom = writeCycloneDxSbom;
 exports.writeQualityBaseline = writeQualityBaseline;
 exports.writeReleaseKpiReport = writeReleaseKpiReport;