@effinrich/forgekit-storybook-plugin 2.0.0

package/dist/chunk-C2HX5UGS.mjs

@@ -0,0 +1,704 @@
+import {
+  COMPONENT_EXTENSIONS,
+  DEFAULT_DEBOUNCE_MS,
+  IGNORED_DIRS,
+  STORYBOOK_META_IMPORT,
+  STORYBOOK_TEST_IMPORT,
+  STORY_FILE_SUFFIX,
+  analyzeComponent
+} from "./chunk-D2RQPIRR.mjs";
+
+// src/core/scan-directory.ts
+import fg from "fast-glob";
+import * as path from "path";
+import * as fs from "fs";
+async function scanDirectory(dir) {
+  const absoluteDir = path.resolve(dir);
+  if (!fs.existsSync(absoluteDir)) {
+    throw new Error(`Directory not found: ${absoluteDir}`);
+  }
+  const extensions = COMPONENT_EXTENSIONS.map((e) => e.replace(".", "")).join(",");
+  const ignorePatterns = [
+    ...IGNORED_DIRS.map((d) => `**/${d}/**`),
+    "**/*.spec.*",
+    "**/*.test.*",
+    "**/*.stories.*",
+    "**/*.styles.*",
+    "**/*.style.*",
+    "**/index.ts",
+    "**/index.tsx"
+  ];
+  const files = await fg(`**/*.{${extensions}}`, {
+    cwd: absoluteDir,
+    ignore: ignorePatterns,
+    absolute: true
+  });
+  const components = [];
+  const withStories = [];
+  const withoutStories = [];
+  const notAnalyzable = [];
+  for (const filePath of files) {
+    const analysis = analyzeComponent(filePath);
+    const storyPath = filePath.replace(/\.tsx?$/, STORY_FILE_SUFFIX);
+    const hasStory = fs.existsSync(storyPath);
+    components.push({ filePath, analysis, hasStory });
+    if (!analysis) {
+      notAnalyzable.push(filePath);
+    } else if (hasStory) {
+      withStories.push(filePath);
+    } else {
+      withoutStories.push(filePath);
+    }
+  }
+  return {
+    components,
+    withStories,
+    withoutStories,
+    notAnalyzable,
+    total: files.length
+  };
+}
+
+// src/core/generate-interaction-tests.ts
+function generateInteractionTests(analysis) {
+  const lines = [];
+  const { props, name, hasChildren } = analysis;
+  const clickHandlers = props.filter(
+    (p) => p.isCallback && (p.name === "onClick" || p.name === "onPress" || p.name === "onSubmit" || p.name === "onClose")
+  );
+  const toggleProps = props.filter(
+    (p) => !p.isCallback && (p.type.toLowerCase() === "boolean" || p.type.toLowerCase() === "bool") && (p.name === "checked" || p.name === "isChecked" || p.name === "selected" || p.name === "open" || p.name === "isOpen")
+  );
+  if (clickHandlers.length > 0) {
+    lines.push(...buildClickTest(name, clickHandlers));
+  }
+  lines.push(...buildRenderTest(name, hasChildren));
+  if (clickHandlers.length > 0 || toggleProps.length > 0) {
+    lines.push("");
+    lines.push(...buildKeyboardTest(name, clickHandlers));
+  }
+  lines.push("");
+  lines.push(...buildA11yTest(name, hasChildren));
+  return lines;
+}
+function buildClickTest(componentName, clickHandlers) {
+  const lines = [];
+  const handler = clickHandlers[0];
+  lines.push(`export const ClickInteraction: Story = {`);
+  lines.push(`  args: {`);
+  lines.push(`    ${handler.name}: fn(),`);
+  lines.push(`  },`);
+  lines.push(`  play: async ({ canvasElement, args }) => {`);
+  lines.push(`    const canvas = within(canvasElement);`);
+  lines.push("");
+  if (handler.name === "onSubmit") {
+    lines.push(
+      `    const submitButton = canvas.getByRole('button', { name: /submit/i });`
+    );
+    lines.push(`    await userEvent.click(submitButton);`);
+    lines.push("");
+    lines.push(`    await expect(args.${handler.name}).toHaveBeenCalledTimes(1);`);
+  } else if (handler.name === "onClose") {
+    lines.push(
+      `    const closeButton = canvas.getByRole('button', { name: /close/i });`
+    );
+    lines.push(`    await userEvent.click(closeButton);`);
+    lines.push("");
+    lines.push(`    await expect(args.${handler.name}).toHaveBeenCalledTimes(1);`);
+  } else {
+    lines.push(
+      `    const element = canvas.getByRole('button');`
+    );
+    lines.push(`    await userEvent.click(element);`);
+    lines.push("");
+    lines.push(`    await expect(args.${handler.name}).toHaveBeenCalledTimes(1);`);
+  }
+  lines.push(`  },`);
+  lines.push(`};`);
+  return lines;
+}
+function buildRenderTest(componentName, hasChildren) {
+  const lines = [];
+  lines.push("");
+  lines.push(`export const RendersCorrectly: Story = {`);
+  if (hasChildren) {
+    lines.push(`  args: {`);
+    lines.push(`    children: 'Test content',`);
+    lines.push(`  },`);
+  }
+  lines.push(`  play: async ({ canvasElement }) => {`);
+  lines.push(`    const canvas = within(canvasElement);`);
+  lines.push("");
+  if (hasChildren) {
+    lines.push(`    const element = canvas.getByText('Test content');`);
+    lines.push(`    await expect(element).toBeInTheDocument();`);
+  } else {
+    lines.push(`    // Verify the component renders without crashing`);
+    lines.push(`    await expect(canvasElement.firstChild).toBeInTheDocument();`);
+  }
+  lines.push(`  },`);
+  lines.push(`};`);
+  return lines;
+}
+function buildA11yTest(componentName, hasChildren) {
+  const lines = [];
+  lines.push(`export const AccessibilityAudit: Story = {`);
+  lines.push(`  tags: ['a11y'],`);
+  if (hasChildren) {
+    lines.push(`  args: {`);
+    lines.push(`    children: '${componentName} content',`);
+    lines.push(`  },`);
+  }
+  lines.push(`  play: async ({ canvasElement }) => {`);
+  lines.push(`    const canvas = within(canvasElement);`);
+  lines.push("");
+  lines.push(`    // Verify component is rendered and visible`);
+  if (hasChildren) {
+    lines.push(
+      `    const element = canvas.getByText('${componentName} content');`
+    );
+    lines.push(`    await expect(element).toBeInTheDocument();`);
+  } else {
+    lines.push(
+      `    await expect(canvasElement.firstChild).toBeInTheDocument();`
+    );
+  }
+  lines.push("");
+  lines.push(`    // Verify no implicit ARIA role violations`);
+  lines.push(`    // The @storybook/addon-a11y will run axe-core checks on this story`);
+  lines.push(`    // Configure rules in .storybook/preview.tsx via the a11y addon parameter`);
+  lines.push(`  },`);
+  lines.push(`};`);
+  return lines;
+}
+function buildKeyboardTest(_componentName, clickHandlers) {
+  const lines = [];
+  const handler = clickHandlers[0];
+  if (!handler) return lines;
+  lines.push(`export const KeyboardNavigation: Story = {`);
+  lines.push(`  args: {`);
+  lines.push(`    ${handler.name}: fn(),`);
+  lines.push(`  },`);
+  lines.push(`  play: async ({ canvasElement, args }) => {`);
+  lines.push(`    const canvas = within(canvasElement);`);
+  lines.push("");
+  lines.push(`    const element = canvas.getByRole('button');`);
+  lines.push(`    await userEvent.tab();`);
+  lines.push(`    await expect(element).toHaveFocus();`);
+  lines.push("");
+  lines.push(`    await userEvent.keyboard('{Enter}');`);
+  lines.push(`    await expect(args.${handler.name}).toHaveBeenCalled();`);
+  lines.push(`  },`);
+  lines.push(`};`);
+  return lines;
+}
+
+// src/core/generate-story-content.ts
+function generateStoryContent(options) {
+  const { analysis, storyTitle, importPath, skipInteractionTests } = options;
+  const { name } = analysis;
+  const lines = [];
+  lines.push(...buildImports(analysis, importPath, skipInteractionTests));
+  lines.push("");
+  lines.push(...buildMeta(analysis, storyTitle));
+  lines.push("");
+  lines.push(`type Story = StoryObj<typeof ${name}>;`);
+  lines.push("");
+  lines.push(...buildDefaultStory(analysis));
+  const variantStories = buildVariantStories(analysis);
+  if (variantStories.length > 0) {
+    lines.push("");
+    lines.push(...variantStories);
+  }
+  if (!skipInteractionTests) {
+    const interactionStories = generateInteractionTests(analysis);
+    if (interactionStories.length > 0) {
+      lines.push("");
+      lines.push(...interactionStories);
+    }
+  }
+  lines.push("");
+  return lines.join("\n");
+}
+function buildImports(analysis, importPath, skipInteractionTests) {
+  const lines = [];
+  const metaImports = ["Meta", "StoryObj"];
+  lines.push(
+    `import type { ${metaImports.join(", ")} } from '${STORYBOOK_META_IMPORT}';`
+  );
+  if (!skipInteractionTests) {
+    const testImports = buildTestImports(analysis);
+    if (testImports.length > 0) {
+      lines.push(
+        `import { ${testImports.join(", ")} } from '${STORYBOOK_TEST_IMPORT}';`
+      );
+    }
+  }
+  if (analysis.usesRouter) {
+    lines.push(
+      `import { withRouter } from 'storybook-addon-react-router-v6';`
+    );
+  }
+  lines.push(`import React from 'react';`);
+  if (analysis.exportType === "default") {
+    lines.push(`import ${analysis.name} from '${importPath}';`);
+  } else {
+    lines.push(`import { ${analysis.name} } from '${importPath}';`);
+  }
+  return lines;
+}
+function buildTestImports(analysis) {
+  const imports = /* @__PURE__ */ new Set();
+  const { props } = analysis;
+  const hasCallbacks = props.some((p) => p.isCallback);
+  const hasInteractiveProps = props.some(
+    (p) => ["string", "number"].includes(inferControlType(p) ?? "")
+  );
+  const hasClickable = props.some(
+    (p) => p.name === "onClick" || p.name === "onPress"
+  );
+  if (hasCallbacks) imports.add("fn");
+  if (hasClickable || hasInteractiveProps) {
+    imports.add("expect");
+    imports.add("within");
+  }
+  if (hasClickable) imports.add("userEvent");
+  if (hasInteractiveProps) imports.add("userEvent");
+  return Array.from(imports);
+}
+function buildMeta(analysis, storyTitle) {
+  const lines = [];
+  const { name, props, usesRouter } = analysis;
+  lines.push(`const meta: Meta<typeof ${name}> = {`);
+  lines.push(`  component: ${name},`);
+  lines.push(`  title: '${storyTitle}',`);
+  lines.push(`  tags: ['autodocs'],`);
+  if (usesRouter) {
+    lines.push(`  decorators: [withRouter],`);
+  }
+  const argTypes = buildArgTypes(props);
+  if (argTypes.length > 0) {
+    lines.push(`  argTypes: {`);
+    lines.push(...argTypes);
+    lines.push(`  },`);
+  }
+  const defaultArgs = buildDefaultArgs(props);
+  if (defaultArgs.length > 0) {
+    lines.push(`  args: {`);
+    lines.push(...defaultArgs);
+    lines.push(`  },`);
+  }
+  lines.push(`};`);
+  lines.push("");
+  lines.push(`export default meta;`);
+  return lines;
+}
+function buildArgTypes(props) {
+  const lines = [];
+  for (const prop of props) {
+    if (prop.name === "children") continue;
+    if (prop.isCallback) {
+      lines.push(`    ${prop.name}: { action: '${prop.name}' },`);
+      continue;
+    }
+    if (prop.unionValues && prop.unionValues.length > 0) {
+      const options = prop.unionValues.map((v) => `'${v}'`).join(", ");
+      lines.push(`    ${prop.name}: {`);
+      lines.push(`      options: [${options}],`);
+      lines.push(`      control: { type: 'select' },`);
+      lines.push(`    },`);
+      continue;
+    }
+    const controlType = inferControlType(prop);
+    if (controlType) {
+      lines.push(`    ${prop.name}: { control: { type: '${controlType}' } },`);
+    }
+  }
+  return lines;
+}
+function buildDefaultArgs(props) {
+  const lines = [];
+  for (const prop of props) {
+    if (!prop.required) continue;
+    if (prop.isCallback) {
+      lines.push(`    ${prop.name}: fn(),`);
+      continue;
+    }
+    const defaultValue = inferDefaultValue(prop);
+    if (defaultValue !== void 0) {
+      lines.push(`    ${prop.name}: ${defaultValue},`);
+    }
+  }
+  return lines;
+}
+function buildDefaultStory(analysis) {
+  const lines = [];
+  const { hasChildren } = analysis;
+  lines.push(`export const Default: Story = {`);
+  if (hasChildren) {
+    lines.push(`  args: {`);
+    lines.push(`    children: '${analysis.name} content',`);
+    lines.push(`  },`);
+  }
+  lines.push(`};`);
+  return lines;
+}
+function buildVariantStories(analysis) {
+  const lines = [];
+  const { props, name } = analysis;
+  const sizeProp = props.find((p) => p.name === "size");
+  if (sizeProp?.unionValues && sizeProp.unionValues.length > 0) {
+    lines.push(`export const Sizes: Story = {`);
+    lines.push(`  render: (args) => (`);
+    lines.push(`    <>`);
+    for (const size of sizeProp.unionValues) {
+      lines.push(
+        `      <${name} {...args} size="${size}">${analysis.hasChildren ? `Size ${size}` : ""}</${name}>`
+      );
+    }
+    lines.push(`    </>`);
+    lines.push(`  ),`);
+    lines.push(`};`);
+    lines.push("");
+  }
+  const variantProp = props.find((p) => p.name === "variant");
+  if (variantProp?.unionValues && variantProp.unionValues.length > 0) {
+    lines.push(`export const Variants: Story = {`);
+    lines.push(`  render: (args) => (`);
+    lines.push(`    <>`);
+    for (const variant of variantProp.unionValues) {
+      lines.push(
+        `      <${name} {...args} variant="${variant}">${analysis.hasChildren ? `Variant ${variant}` : ""}</${name}>`
+      );
+    }
+    lines.push(`    </>`);
+    lines.push(`  ),`);
+    lines.push(`};`);
+    lines.push("");
+  }
+  const colorPaletteProp = props.find((p) => p.name === "colorPalette");
+  if (colorPaletteProp?.unionValues && colorPaletteProp.unionValues.length > 0) {
+    lines.push(`export const ColorPalettes: Story = {`);
+    lines.push(`  render: (args) => (`);
+    lines.push(`    <>`);
+    for (const palette of colorPaletteProp.unionValues) {
+      lines.push(
+        `      <${name} {...args} colorPalette="${palette}">${analysis.hasChildren ? palette : ""}</${name}>`
+      );
+    }
+    lines.push(`    </>`);
+    lines.push(`  ),`);
+    lines.push(`};`);
+    lines.push("");
+  }
+  const disabledProp = props.find(
+    (p) => p.name === "disabled" || p.name === "isDisabled"
+  );
+  if (disabledProp) {
+    lines.push(`export const Disabled: Story = {`);
+    lines.push(`  args: {`);
+    lines.push(`    ${disabledProp.name}: true,`);
+    lines.push(`  },`);
+    lines.push(`};`);
+  }
+  return lines;
+}
+function inferControlType(prop) {
+  const type = prop.type.toLowerCase();
+  if (type === "boolean" || type === "bool") return "boolean";
+  if (type === "string") return "text";
+  if (type === "number") return "number";
+  if (type.includes("react.reactnode") || type.includes("reactnode"))
+    return null;
+  if (prop.isCallback) return null;
+  return null;
+}
+function inferDefaultValue(prop) {
+  if (prop.defaultValue) return prop.defaultValue;
+  const type = prop.type.toLowerCase();
+  if (type === "string") return `'Example ${prop.name}'`;
+  if (type === "number") return "0";
+  if (type === "boolean" || type === "bool") return "false";
+  if (prop.unionValues && prop.unionValues.length > 0) {
+    return `'${prop.unionValues[0]}'`;
+  }
+  if (prop.isCallback) return "fn()";
+  return void 0;
+}
+
+// src/core/score-coverage.ts
+function scoreCoverage(covered, total) {
+  if (total === 0) {
+    return { covered: 0, total: 0, percentage: 0, grade: "F" };
+  }
+  const percentage = Math.round(covered / total * 100);
+  let grade;
+  if (percentage >= 90) grade = "A";
+  else if (percentage >= 75) grade = "B";
+  else if (percentage >= 50) grade = "C";
+  else if (percentage >= 25) grade = "D";
+  else grade = "F";
+  return { covered, total, percentage, grade };
+}
+
+// src/core/infer-title.ts
+import * as path2 from "path";
+function inferStoryTitle(filePath, baseDir) {
+  const resolvedBase = baseDir ? path2.resolve(baseDir) : path2.dirname(filePath);
+  const resolvedFile = path2.resolve(filePath);
+  let relative2 = path2.relative(resolvedBase, resolvedFile);
+  const fileName = path2.basename(relative2, path2.extname(relative2));
+  const dirPart = path2.dirname(relative2);
+  if (dirPart === ".") {
+    return `Components / ${toPascalCase(fileName)}`;
+  }
+  let segments = dirPart.split(path2.sep);
+  const stripPrefixes = ["src", "lib", "source"];
+  while (segments.length > 0 && stripPrefixes.includes(segments[0].toLowerCase())) {
+    segments.shift();
+  }
+  const parts = segments.map((seg) => toPascalCase(seg));
+  const componentName = toPascalCase(fileName);
+  parts.push(componentName);
+  const deduped = [];
+  for (const part of parts) {
+    if (part !== deduped[deduped.length - 1]) {
+      deduped.push(part);
+    }
+  }
+  if (deduped.length === 0) {
+    return `Components / ${componentName}`;
+  }
+  return deduped.join(" / ");
+}
+function toPascalCase(str) {
+  return str.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+
+// src/api/forge-story.ts
+import * as fs2 from "fs";
+import * as path3 from "path";
+async function forgeStory(options) {
+  const { componentPath, storyTitle, skipInteractionTests = false, overwrite = false, dryRun = false } = options;
+  const resolvedPath = resolveComponentPath(componentPath);
+  if (!resolvedPath) {
+    throw new Error(`Component file not found: ${componentPath}`);
+  }
+  const storyPath = resolvedPath.replace(/\.tsx?$/, STORY_FILE_SUFFIX);
+  if (fs2.existsSync(storyPath) && !overwrite) {
+    throw new Error(`Story already exists: ${storyPath}. Use --overwrite to replace.`);
+  }
+  const analysis = analyzeComponent(resolvedPath);
+  if (!analysis) {
+    throw new Error(`Could not analyze component at ${resolvedPath}. Ensure it exports a React component.`);
+  }
+  const title = storyTitle ?? inferStoryTitle(resolvedPath);
+  const importPath = `./${analysis.fileName}`;
+  const content = generateStoryContent({
+    analysis,
+    storyTitle: title,
+    importPath,
+    skipInteractionTests
+  });
+  const storiesGenerated = collectStoriesGenerated(analysis, skipInteractionTests);
+  let written = false;
+  if (!dryRun) {
+    const dir = path3.dirname(storyPath);
+    fs2.mkdirSync(dir, { recursive: true });
+    fs2.writeFileSync(storyPath, content, "utf-8");
+    written = true;
+  }
+  return { storyPath, content, analysis, storiesGenerated, written };
+}
+function resolveComponentPath(componentPath) {
+  const resolved = path3.resolve(componentPath);
+  if (fs2.existsSync(resolved)) return resolved;
+  for (const ext of COMPONENT_EXTENSIONS) {
+    const withExt = resolved + ext;
+    if (fs2.existsSync(withExt)) return withExt;
+  }
+  return null;
+}
+function collectStoriesGenerated(analysis, skipInteractionTests) {
+  const stories = ["Default"];
+  if (analysis.props.some((p) => p.name === "size" && p.unionValues?.length)) {
+    stories.push("Sizes");
+  }
+  if (analysis.props.some((p) => p.name === "variant" && p.unionValues?.length)) {
+    stories.push("Variants");
+  }
+  if (analysis.props.some((p) => p.name === "colorPalette" && p.unionValues?.length)) {
+    stories.push("ColorPalettes");
+  }
+  if (analysis.props.some((p) => p.name === "disabled" || p.name === "isDisabled")) {
+    stories.push("Disabled");
+  }
+  if (!skipInteractionTests) {
+    stories.push("RendersCorrectly", "AccessibilityAudit");
+    if (analysis.props.some(
+      (p) => p.isCallback && ["onClick", "onPress", "onSubmit", "onClose"].includes(p.name)
+    )) {
+      stories.push("ClickInteraction", "KeyboardNavigation");
+    }
+  }
+  return stories;
+}
+
+// src/core/watch.ts
+import { watch as chokidarWatch } from "chokidar";
+import * as path4 from "path";
+import * as fs3 from "fs";
+function watchDirectory(options, callback) {
+  const {
+    dir,
+    ignore = [],
+    debounceMs = DEFAULT_DEBOUNCE_MS,
+    skipInteractionTests = false
+  } = options;
+  const absoluteDir = path4.resolve(dir);
+  if (!fs3.existsSync(absoluteDir)) {
+    throw new Error(`Watch directory not found: ${absoluteDir}`);
+  }
+  const extensions = COMPONENT_EXTENSIONS.map((e) => e.replace(".", ""));
+  const globPattern = `**/*.{${extensions.join(",")}}`;
+  const ignored = [
+    ...IGNORED_DIRS.map((d) => `**/${d}/**`),
+    "**/*.spec.*",
+    "**/*.test.*",
+    "**/*.stories.*",
+    "**/*.styles.*",
+    "**/*.style.*",
+    "**/index.{ts,tsx}",
+    ...ignore
+  ];
+  const pending = /* @__PURE__ */ new Map();
+  const watcher = chokidarWatch(globPattern, {
+    cwd: absoluteDir,
+    ignored,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 100,
+      pollInterval: 50
+    }
+  });
+  const processChange = async (relativePath) => {
+    const filePath = path4.join(absoluteDir, relativePath);
+    const storyPath = filePath.replace(/\.tsx?$/, STORY_FILE_SUFFIX);
+    const isUpdate = fs3.existsSync(storyPath);
+    try {
+      await forgeStory({
+        componentPath: filePath,
+        skipInteractionTests,
+        overwrite: true,
+        quiet: true
+      });
+      callback?.({
+        type: isUpdate ? "update" : "generate",
+        file: filePath,
+        storyPath
+      });
+    } catch (err) {
+      callback?.({
+        type: "error",
+        file: filePath,
+        error: err
+      });
+    }
+  };
+  const debouncedProcess = (relativePath) => {
+    if (pending.has(relativePath)) {
+      clearTimeout(pending.get(relativePath));
+    }
+    pending.set(
+      relativePath,
+      setTimeout(() => {
+        pending.delete(relativePath);
+        processChange(relativePath);
+      }, debounceMs)
+    );
+  };
+  watcher.on("change", debouncedProcess);
+  watcher.on("add", debouncedProcess);
+  watcher.on("ready", () => callback?.({ type: "ready" }));
+  return {
+    async close() {
+      for (const timeout of pending.values()) {
+        clearTimeout(timeout);
+      }
+      pending.clear();
+      await watcher.close();
+    }
+  };
+}
+
+// src/api/forge-stories.ts
+import * as path5 from "path";
+async function forgeStories(options) {
+  const {
+    dir,
+    skipInteractionTests = false,
+    overwrite = false,
+    dryRun = false,
+    includeComponentTests = false
+  } = options;
+  const { forgeTest } = includeComponentTests ? await import("./forge-test-EGP3AGFI.mjs") : { forgeTest: null };
+  const absoluteDir = path5.resolve(dir);
+  const scan = await scanDirectory(absoluteDir);
+  let generated = 0;
+  let failed = 0;
+  const errors = [];
+  const filesToProcess = overwrite ? [...scan.withoutStories, ...scan.withStories] : scan.withoutStories;
+  for (const filePath of filesToProcess) {
+    try {
+      await forgeStory({
+        componentPath: filePath,
+        skipInteractionTests,
+        overwrite: true,
+        dryRun,
+        quiet: true
+      });
+      generated++;
+      if (forgeTest) {
+        try {
+          await forgeTest({
+            componentPath: filePath,
+            overwrite: true,
+            dryRun,
+            quiet: true
+          });
+        } catch {
+        }
+      }
+    } catch (err) {
+      failed++;
+      errors.push({
+        file: filePath,
+        error: err.message
+      });
+    }
+  }
+  const totalAnalyzable = scan.total - scan.notAnalyzable.length;
+  const totalCovered = overwrite ? generated : scan.withStories.length + generated;
+  const coverage = scoreCoverage(totalCovered, totalAnalyzable);
+  return {
+    generated,
+    failed,
+    alreadyCovered: scan.withStories.length,
+    notAnalyzable: scan.notAnalyzable.length,
+    total: totalAnalyzable,
+    coverage,
+    errors
+  };
+}
+
+export {
+  scanDirectory,
+  generateInteractionTests,
+  generateStoryContent,
+  scoreCoverage,
+  inferStoryTitle,
+  forgeStory,
+  watchDirectory,
+  forgeStories
+};
+//# sourceMappingURL=chunk-C2HX5UGS.mjs.map