@fragments-sdk/cli 0.10.1 → 0.12.1

package/dist/scan-generate-SYU4PYZD.js

@@ -0,0 +1,1115 @@
+import { createRequire as __banner_createRequire } from 'module'; const require = __banner_createRequire(import.meta.url);
+import {
+  createComponentExtractor
+} from "./chunk-JJ2VRTBU.js";
+import "./chunk-AM4MRTMN.js";
+import {
+  discoverAllComponents
+} from "./chunk-OQKMEFOS.js";
+import "./chunk-D2CDBRNU.js";
+import {
+  BRAND
+} from "./chunk-WFS63PCW.js";
+import "./chunk-Z7EY4VHE.js";
+
+// src/commands/scan-generate.ts
+import { readFile, writeFile, access, mkdir } from "fs/promises";
+import { resolve, basename, dirname, relative, join } from "path";
+import * as ts from "typescript";
+import pc from "picocolors";
+async function scanGenerate(options) {
+  const scanPath = resolve(options.scanPath);
+  const generated = [];
+  const skipped = [];
+  const errors = [];
+  console.log(pc.cyan(`
+${BRAND.name} Scan \u2192 Generate
+`));
+  console.log(pc.dim(`Scanning: ${scanPath}
+`));
+  console.log(pc.dim("Phase 1: Discovering components..."));
+  const defaultScanPatterns = [
+    "**/*.tsx",
+    "**/*.ts"
+  ];
+  const components = await discoverAllComponents(scanPath, {
+    patterns: options.patterns || defaultScanPatterns,
+    exclude: [
+      "**/*.test.*",
+      "**/*.spec.*",
+      "**/*.stories.*",
+      "**/*.fragment.*",
+      "**/*.d.ts",
+      "**/__tests__/**",
+      "**/__mocks__/**",
+      "**/node_modules/**",
+      "**/dist/**"
+    ]
+  });
+  if (components.length === 0) {
+    console.log(
+      pc.yellow("No components found. Check the path or file patterns.")
+    );
+    return {
+      success: false,
+      generated: [],
+      skipped: [],
+      errors: [{ name: "*", error: "No components found" }],
+      averageConfidence: 0
+    };
+  }
+  console.log(pc.green(`  Found ${components.length} components`));
+  console.log(pc.dim("\nPhase 2: Extracting component metadata..."));
+  const extractor = createComponentExtractor(options.tsconfig);
+  const componentDataList = [];
+  const extractionStart = performance.now();
+  for (const comp of components) {
+    let meta = null;
+    try {
+      meta = extractor.extract(comp.sourcePath, comp.name);
+    } catch {
+    }
+    if (meta && !meta.composition) {
+      try {
+        const subComponents = await detectCompoundComponents(comp.sourcePath, comp.name);
+        if (subComponents.length > 0) {
+          meta = {
+            ...meta,
+            composition: {
+              pattern: "compound",
+              parts: subComponents.map((name) => ({ name, props: {} })),
+              required: []
+            }
+          };
+        }
+      } catch {
+      }
+    }
+    let storyVariants = [];
+    if (!options.skipStorybook && comp.storyPath) {
+      try {
+        storyVariants = await extractStoryVariantsFromFile(comp.storyPath);
+      } catch {
+      }
+    }
+    componentDataList.push({
+      component: comp,
+      meta,
+      storyVariants
+    });
+  }
+  extractor.dispose();
+  const extractionMs = (performance.now() - extractionStart).toFixed(0);
+  const propsExtracted = componentDataList.filter(
+    (d) => d.meta && Object.keys(d.meta.props).length > 0
+  ).length;
+  const compoundCount = componentDataList.filter(
+    (d) => d.meta?.composition !== null
+  ).length;
+  console.log(pc.green(`  Extracted props for ${propsExtracted} components (${extractionMs}ms)`));
+  if (compoundCount > 0) {
+    console.log(pc.green(`  Detected ${compoundCount} compound component(s) with sub-component props`));
+  }
+  let enrichments = /* @__PURE__ */ new Map();
+  let enrichmentCost;
+  if (options.enrich) {
+    console.log(pc.dim("\nPhase 3: Enriching with AI..."));
+    const enrichResult = await enrichComponents(componentDataList, {
+      dryRun: options.dryRun,
+      provider: options.provider,
+      apiKey: options.apiKey,
+      model: options.model
+    });
+    enrichments = enrichResult.enrichments;
+    if (enrichResult.model && enrichResult.totalInputTokens > 0) {
+      const { calculateCost } = await import("./ai-client-I6MDWNYA.js");
+      enrichmentCost = calculateCost(
+        enrichResult.model,
+        enrichResult.totalInputTokens,
+        enrichResult.totalOutputTokens
+      );
+    }
+  }
+  console.log(pc.dim(`
+Phase ${options.enrich ? "4" : "3"}: Generating fragment files...`));
+  for (const data of componentDataList) {
+    const comp = data.component;
+    const componentDir = dirname(comp.sourcePath);
+    const componentBaseName = basename(comp.sourcePath, ".tsx");
+    let fragmentDir;
+    if (options.outputDir) {
+      fragmentDir = resolve(options.outputDir, comp.name);
+      await mkdir(fragmentDir, { recursive: true });
+    } else {
+      fragmentDir = componentDir;
+    }
+    const fragmentPath = join(
+      fragmentDir,
+      `${componentBaseName}${BRAND.fileExtension}`
+    );
+    let fragmentExists = false;
+    try {
+      await access(fragmentPath);
+      fragmentExists = true;
+    } catch {
+    }
+    if (fragmentExists && !options.force) {
+      skipped.push({ name: comp.name, reason: "Fragment already exists" });
+      if (options.verbose) {
+        console.log(pc.dim(`  Skipping ${comp.name} (fragment exists)`));
+      }
+      continue;
+    }
+    try {
+      const enrichment = enrichments.get(comp.name);
+      const confidence = calculateFieldConfidence(data, enrichment);
+      const importPath = computeImportPath(
+        fragmentDir,
+        comp.sourcePath,
+        componentBaseName
+      );
+      const content = generateFragmentWithTodos(
+        comp.name,
+        importPath,
+        data,
+        confidence,
+        enrichment
+      );
+      await writeFile(fragmentPath, content, "utf-8");
+      const relPath = relative(process.cwd(), fragmentPath);
+      generated.push({
+        name: comp.name,
+        path: relPath,
+        confidence: confidence.score,
+        todoCount: confidence.todoFields.length,
+        enriched: !!enrichment
+      });
+      const confColor = confidence.score >= 70 ? pc.green : confidence.score >= 40 ? pc.yellow : pc.red;
+      console.log(
+        pc.green(`  \u2713 ${comp.name}`) + pc.dim(` (confidence: `) + confColor(`${confidence.score}`) + pc.dim(`, TODOs: ${confidence.todoFields.length})`)
+      );
+    } catch (e) {
+      errors.push({
+        name: comp.name,
+        error: e instanceof Error ? e.message : String(e)
+      });
+      console.log(pc.red(`  \u2717 ${comp.name}: ${e instanceof Error ? e.message : String(e)}`));
+    }
+  }
+  const avgConfidence = generated.length > 0 ? Math.round(
+    generated.reduce((sum, g) => sum + g.confidence, 0) / generated.length
+  ) : 0;
+  console.log(pc.dim("\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(pc.green(`
+\u2713 Generated ${generated.length} fragment file(s)`));
+  if (skipped.length > 0) {
+    console.log(
+      pc.dim(`  Skipped ${skipped.length} (use --force to overwrite)`)
+    );
+  }
+  if (errors.length > 0) {
+    console.log(pc.yellow(`  ${errors.length} error(s)`));
+  }
+  console.log(pc.dim(`  Average confidence: ${avgConfidence}/100`));
+  if (options.enrich) {
+    const enrichedCount = generated.filter((g) => g.enriched).length;
+    console.log(pc.dim(`  Enriched: ${enrichedCount}/${generated.length} components`));
+    if (enrichmentCost !== void 0 && enrichmentCost > 0) {
+      console.log(pc.dim(`  Estimated cost: $${enrichmentCost.toFixed(4)}`));
+    }
+  }
+  const totalTodos = generated.reduce((sum, g) => sum + g.todoCount, 0);
+  if (totalTodos > 0) {
+    console.log(
+      pc.dim(`  Total TODOs: ${totalTodos}`) + pc.dim(` \u2014 search for "TODO:" in generated files`)
+    );
+  }
+  console.log();
+  return {
+    success: errors.length === 0,
+    generated,
+    skipped,
+    errors,
+    averageConfidence: avgConfidence,
+    enrichmentCost
+  };
+}
+async function extractComponentJSDoc(filePath, componentName) {
+  const content = await readFile(filePath, "utf-8");
+  return extractComponentJSDocFromSource(content, filePath, componentName);
+}
+function extractComponentJSDocFromSource(source, filePath, componentName) {
+  const sourceFile = ts.createSourceFile(
+    filePath,
+    source,
+    ts.ScriptTarget.ESNext,
+    true,
+    filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS
+  );
+  const targetName = componentName || basename(filePath).replace(/\.(tsx?|jsx?)$/, "");
+  let componentDoc = null;
+  let propsInterfaceDoc = null;
+  for (const statement of sourceFile.statements) {
+    if (ts.isFunctionDeclaration(statement) && statement.name?.text === targetName && hasExportModifier(statement)) {
+      const doc = getLeadingJSDoc(statement, sourceFile);
+      if (doc) componentDoc = doc;
+    }
+    if (ts.isVariableStatement(statement) && hasExportModifier(statement)) {
+      for (const decl of statement.declarationList.declarations) {
+        if (ts.isIdentifier(decl.name) && decl.name.text === targetName) {
+          const doc = getLeadingJSDoc(statement, sourceFile);
+          if (doc) componentDoc = doc;
+        }
+      }
+    }
+    if (ts.isFunctionDeclaration(statement) && hasDefaultExportModifier(statement)) {
+      const doc = getLeadingJSDoc(statement, sourceFile);
+      if (doc) componentDoc = doc;
+    }
+    if (ts.isInterfaceDeclaration(statement) && (statement.name.text === `${targetName}Props` || statement.name.text === `${targetName}Properties`)) {
+      const doc = getLeadingJSDoc(statement, sourceFile);
+      if (doc) propsInterfaceDoc = doc;
+    }
+  }
+  return componentDoc || propsInterfaceDoc;
+}
+function hasExportModifier(node) {
+  const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0;
+  return modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
+function hasDefaultExportModifier(node) {
+  const modifiers = ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0;
+  if (!modifiers) return false;
+  return modifiers.some((m) => m.kind === ts.SyntaxKind.ExportKeyword) && modifiers.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
+}
+function getLeadingJSDoc(node, sourceFile) {
+  const fullText = sourceFile.getFullText();
+  const nodeStart = node.getFullStart();
+  const nodePos = node.getStart(sourceFile);
+  const leadingText = fullText.slice(nodeStart, nodePos);
+  const jsDocMatch = leadingText.match(/\/\*\*([\s\S]*?)\*\//);
+  if (!jsDocMatch) return null;
+  const lines = jsDocMatch[1].split("\n");
+  const descriptionLines = [];
+  for (const line of lines) {
+    const trimmed = line.replace(/^\s*\*?\s?/, "").trim();
+    if (trimmed.startsWith("@")) break;
+    if (trimmed) descriptionLines.push(trimmed);
+  }
+  return descriptionLines.length > 0 ? descriptionLines.join(" ") : null;
+}
+async function detectCompoundComponents(filePath, primaryComponentName) {
+  const content = await readFile(filePath, "utf-8");
+  return detectCompoundComponentsFromSource(content, filePath, primaryComponentName);
+}
+function detectCompoundComponentsFromSource(source, filePath, primaryComponentName) {
+  const sourceFile = ts.createSourceFile(
+    filePath,
+    source,
+    ts.ScriptTarget.ESNext,
+    true,
+    filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS
+  );
+  const subComponents = [];
+  function visit(node) {
+    if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression) && ts.isIdentifier(node.expression.expression) && node.expression.expression.text === "Object" && node.expression.name.text === "assign" && node.arguments.length >= 2) {
+      const secondArg = node.arguments[1];
+      if (ts.isObjectLiteralExpression(secondArg)) {
+        for (const prop of secondArg.properties) {
+          if (ts.isShorthandPropertyAssignment(prop)) {
+            subComponents.push(prop.name.text);
+          } else if (ts.isPropertyAssignment(prop) && ts.isIdentifier(prop.name)) {
+            subComponents.push(prop.name.text);
+          }
+        }
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  ts.forEachChild(sourceFile, visit);
+  if (subComponents.length === 0 && primaryComponentName) {
+    const exportedNames = [];
+    for (const statement of sourceFile.statements) {
+      if (ts.isExportDeclaration(statement) && statement.exportClause) {
+        if (ts.isNamedExports(statement.exportClause)) {
+          for (const element of statement.exportClause.elements) {
+            exportedNames.push(element.name.text);
+          }
+        }
+      }
+      if (ts.isFunctionDeclaration(statement) && statement.name) {
+        const modifiers = ts.canHaveModifiers(statement) ? ts.getModifiers(statement) : void 0;
+        if (modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
+          exportedNames.push(statement.name.text);
+        }
+      }
+      if (ts.isVariableStatement(statement)) {
+        const modifiers = ts.canHaveModifiers(statement) ? ts.getModifiers(statement) : void 0;
+        if (modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) {
+          for (const decl of statement.declarationList.declarations) {
+            if (ts.isIdentifier(decl.name)) {
+              exportedNames.push(decl.name.text);
+            }
+          }
+        }
+      }
+    }
+    const prefix = primaryComponentName;
+    for (const name of exportedNames) {
+      if (name !== prefix && name.startsWith(prefix) && /^[A-Z]/.test(name.slice(prefix.length))) {
+        const subName = name.slice(prefix.length);
+        subComponents.push(subName);
+      }
+    }
+  }
+  return subComponents;
+}
+async function extractStoryVariantsFromFile(storyPath) {
+  const content = await readFile(storyPath, "utf-8");
+  const variants = [];
+  const exportMatches = content.matchAll(
+    /export\s+const\s+([A-Z][a-zA-Z0-9]*)\s*[=:]/g
+  );
+  for (const match of exportMatches) {
+    const name = match[1];
+    if (name === "default" || name.endsWith("Args") || name.endsWith("Meta")) {
+      continue;
+    }
+    const args = extractStoryArgs(content, name);
+    variants.push({ name, args });
+  }
+  return variants;
+}
+function extractStoryArgs(content, storyName) {
+  const storyPattern = new RegExp(
+    `export\\s+const\\s+${storyName}[^=]*=\\s*\\{([\\s\\S]*?)\\n\\};`
+  );
+  const storyMatch = content.match(storyPattern);
+  if (!storyMatch) return {};
+  const storyBody = storyMatch[1];
+  const argsStart = storyBody.indexOf("args:");
+  if (argsStart === -1) return {};
+  const braceStart = storyBody.indexOf("{", argsStart);
+  if (braceStart === -1) return {};
+  let depth = 0;
+  let braceEnd = -1;
+  for (let i = braceStart; i < storyBody.length; i++) {
+    if (storyBody[i] === "{") depth++;
+    else if (storyBody[i] === "}") {
+      depth--;
+      if (depth === 0) {
+        braceEnd = i;
+        break;
+      }
+    }
+  }
+  if (braceEnd === -1) return {};
+  const argsBlock = storyBody.slice(braceStart + 1, braceEnd).trim();
+  return parseArgsBlock(argsBlock);
+}
+function parseArgsBlock(argsBlock) {
+  const args = {};
+  const pairPattern = /(\w+)\s*:\s*(?:['"]([^'"]*?)['"]|(true|false)|(\d+(?:\.\d+)?))/g;
+  let pairMatch;
+  while ((pairMatch = pairPattern.exec(argsBlock)) !== null) {
+    const key = pairMatch[1];
+    if (pairMatch[2] !== void 0) {
+      args[key] = pairMatch[2];
+    } else if (pairMatch[3] !== void 0) {
+      args[key] = pairMatch[3] === "true";
+    } else if (pairMatch[4] !== void 0) {
+      args[key] = Number(pairMatch[4]);
+    }
+  }
+  return args;
+}
+function buildEnrichmentSystemPrompt() {
+  return `You are a senior frontend architect and design system expert.
+Given a component's metadata (name, description, props, composition), generate knowledge fields that help AI models use the component correctly.
+
+Respond ONLY with a JSON object. No explanation, no markdown outside the JSON.
+
+The JSON must have exactly these fields:
+{
+  "when": ["..."],      // 3-5 scenarios when this component should be used
+  "whenNot": ["..."],   // 2-4 scenarios when NOT to use this component (suggest alternatives)
+  "guidelines": ["..."], // 2-3 usage guidelines or best practices
+  "a11yRules": ["..."], // 2-4 accessibility rules or requirements
+  "scenarioTags": ["..."], // 3-5 dot-notation scenario tags (e.g., "form.input.text", "layout.container.card")
+  "tags": ["..."]       // 3-5 search keywords for component discovery
+}
+
+Rules:
+- "when" items should describe concrete UI scenarios (e.g., "Displaying grouped content with a header, body, and footer")
+- "whenNot" items should name a better alternative (e.g., "Simple text grouping without visual separation \u2014 use a div or Stack instead")
+- "guidelines" should be actionable best practices
+- "a11yRules" should reference WCAG or ARIA patterns where relevant
+- "scenarioTags" use dot notation: category.subcategory.detail
+- "tags" should be lowercase single words or short phrases for search
+- Keep each item to 1 sentence. Be specific, not generic.`;
+}
+function buildEnrichmentUserPrompt(name, data) {
+  const props = data.meta?.props ?? {};
+  const localProps = Object.entries(props).filter(([_, p]) => p.source === "local");
+  const composition = data.meta?.composition ?? null;
+  const description = data.meta?.description || "";
+  const category = inferCategoryFromMeta(
+    name,
+    Object.fromEntries(localProps)
+  );
+  const lines = [
+    `Component: ${name}`,
+    `Category: ${category}`
+  ];
+  if (description) {
+    lines.push(`Description: ${description}`);
+  }
+  if (localProps.length > 0) {
+    lines.push("");
+    lines.push("Props:");
+    for (const [propName, prop] of localProps) {
+      let propLine = `  - ${propName}: ${prop.typeKind}`;
+      if (prop.values && prop.values.length > 0) {
+        propLine += ` (${prop.values.join(" | ")})`;
+      }
+      if (prop.required) propLine += " [required]";
+      if (prop.description) propLine += ` \u2014 ${prop.description}`;
+      lines.push(propLine);
+    }
+  }
+  if (composition && composition.parts.length > 0) {
+    lines.push("");
+    lines.push(`Composition: ${composition.pattern} pattern`);
+    lines.push(`Sub-components: ${composition.parts.map((p) => p.name).join(", ")}`);
+  }
+  if (data.storyVariants.length > 0) {
+    lines.push("");
+    lines.push(`Known variants: ${data.storyVariants.map((v) => v.name).join(", ")}`);
+  }
+  return lines.join("\n");
+}
+function parseEnrichmentResponse(text) {
+  const empty = {
+    when: [],
+    whenNot: [],
+    guidelines: [],
+    a11yRules: [],
+    scenarioTags: [],
+    tags: []
+  };
+  try {
+    const jsonMatch = text.match(/```json\n?([\s\S]*?)\n?```/) || text.match(/\{[\s\S]*\}/);
+    const jsonStr = jsonMatch ? jsonMatch[1] || jsonMatch[0] : text;
+    const parsed = JSON.parse(jsonStr);
+    const getArray = (key, maxLen) => {
+      const val = parsed[key];
+      if (!Array.isArray(val)) return [];
+      return val.filter((item) => typeof item === "string").slice(0, maxLen);
+    };
+    return {
+      when: getArray("when", 5),
+      whenNot: getArray("whenNot", 4),
+      guidelines: getArray("guidelines", 3),
+      a11yRules: getArray("a11yRules", 4),
+      scenarioTags: getArray("scenarioTags", 5),
+      tags: getArray("tags", 5)
+    };
+  } catch {
+    return empty;
+  }
+}
+async function enrichComponents(componentDataList, options) {
+  const enrichments = /* @__PURE__ */ new Map();
+  let totalInputTokens = 0;
+  let totalOutputTokens = 0;
+  const {
+    detectProvider,
+    getApiKey,
+    createAIClient,
+    generateCompletion,
+    ENRICHMENT_MODELS
+  } = await import("./ai-client-I6MDWNYA.js");
+  const provider = detectProvider({ provider: options.provider, apiKey: options.apiKey });
+  if (provider === "none") {
+    console.log(pc.yellow("  No API key found. Set ANTHROPIC_API_KEY or OPENAI_API_KEY, or use --api-key"));
+    console.log(pc.yellow("  Skipping enrichment \u2014 fragment files will have TODO markers instead.\n"));
+    return { enrichments, totalInputTokens: 0, totalOutputTokens: 0, model: "" };
+  }
+  const apiKey = getApiKey(provider, options.apiKey);
+  if (!apiKey) {
+    console.log(pc.yellow("  API key not found for provider: " + provider));
+    console.log(pc.yellow("  Skipping enrichment.\n"));
+    return { enrichments, totalInputTokens: 0, totalOutputTokens: 0, model: "" };
+  }
+  const model = options.model || ENRICHMENT_MODELS[provider];
+  if (options.dryRun) {
+    for (const data of componentDataList) {
+      console.log(pc.dim(`  Would enrich: ${data.component.name}`));
+    }
+    return { enrichments, totalInputTokens: 0, totalOutputTokens: 0, model };
+  }
+  const client = await createAIClient(provider, apiKey);
+  const systemPrompt = buildEnrichmentSystemPrompt();
+  for (const data of componentDataList) {
+    const name = data.component.name;
+    process.stdout.write(pc.dim(`  Enriching ${name}...`));
+    try {
+      const userPrompt = buildEnrichmentUserPrompt(name, data);
+      const result = await generateCompletion(client, provider, model, systemPrompt, userPrompt, 512);
+      totalInputTokens += result.inputTokens;
+      totalOutputTokens += result.outputTokens;
+      const enrichment = parseEnrichmentResponse(result.text);
+      const fieldCount = enrichment.when.length + enrichment.whenNot.length + enrichment.guidelines.length + enrichment.a11yRules.length + enrichment.scenarioTags.length + enrichment.tags.length;
+      enrichments.set(name, enrichment);
+      process.stdout.write(`\r  ${pc.green("\u2713")} ${name} (${fieldCount} fields)
+`);
+    } catch (e) {
+      const msg = e instanceof Error ? e.message : String(e);
+      process.stdout.write(`\r  ${pc.yellow("!")} ${name}: ${msg}
+`);
+    }
+  }
+  return { enrichments, totalInputTokens, totalOutputTokens, model };
+}
+function buildEnrichedUsageBlock(enrichment) {
+  const lines = [];
+  lines.push("  usage: {");
+  if (enrichment.when.length > 0) {
+    lines.push("    when: [");
+    for (const item of enrichment.when) {
+      lines.push(`      '${escapeQuotes(item)}',`);
+    }
+    lines.push("    ],");
+  } else {
+    lines.push("    when: [],");
+  }
+  if (enrichment.whenNot.length > 0) {
+    lines.push("    whenNot: [");
+    for (const item of enrichment.whenNot) {
+      lines.push(`      '${escapeQuotes(item)}',`);
+    }
+    lines.push("    ],");
+  } else {
+    lines.push("    whenNot: [],");
+  }
+  if (enrichment.guidelines.length > 0) {
+    lines.push("    guidelines: [");
+    for (const item of enrichment.guidelines) {
+      lines.push(`      '${escapeQuotes(item)}',`);
+    }
+    lines.push("    ],");
+  }
+  lines.push("  },");
+  return lines.join("\n");
+}
+function calculateFieldConfidence(data, enrichment) {
+  let score = 0;
+  const todoFields = [];
+  const props = data.meta?.props ?? {};
+  const localEntries = Object.values(props).filter((p) => p.source === "local");
+  const hasProps = localEntries.length > 0;
+  if (hasProps) {
+    score += 30;
+  }
+  if (data.meta?.description) {
+    score += 15;
+  } else {
+    todoFields.push("meta.description");
+  }
+  const localProps = Object.fromEntries(
+    Object.entries(props).filter(([_, p]) => p.source === "local")
+  );
+  const category = inferCategoryFromMeta(data.component.name, localProps);
+  if (category !== "Components") {
+    score += 10;
+  } else {
+    todoFields.push("meta.category");
+  }
+  if (data.storyVariants.length > 0) {
+    score += 25;
+  }
+  if (hasProps) {
+    const allResolved = localEntries.every((p) => p.typeKind !== "custom");
+    if (allResolved) {
+      score += 10;
+    }
+  }
+  if (data.meta?.composition && data.meta.composition.parts.length > 0) {
+    score += 10;
+  }
+  if (hasProps) {
+    const hasDefaults = localEntries.some((p) => p.default !== void 0);
+    if (hasDefaults) {
+      score += 5;
+    }
+  }
+  if (enrichment && enrichment.when.length > 0) {
+    score += 10;
+  } else {
+    todoFields.push("usage.when");
+  }
+  if (enrichment && enrichment.whenNot.length > 0) {
+    score += 5;
+  } else {
+    todoFields.push("usage.whenNot");
+  }
+  if (enrichment && enrichment.guidelines.length > 0) {
+    score += 5;
+  }
+  if (enrichment && enrichment.tags.length > 0) {
+    score += 5;
+  }
+  return { score: Math.min(score, 100), todoFields };
+}
+var CATEGORY_PATTERNS = {
+  Actions: ["button", "action", "cta", "fab", "floatingaction"],
+  Forms: [
+    "form",
+    "input",
+    "select",
+    "checkbox",
+    "radio",
+    "textarea",
+    "field",
+    "textfield",
+    "datepicker",
+    "switch",
+    "slider",
+    "segmented"
+  ],
+  Layout: [
+    "layout",
+    "container",
+    "grid",
+    "flex",
+    "stack",
+    "box",
+    "divider",
+    "spacer",
+    "sidebar"
+  ],
+  Navigation: [
+    "nav",
+    "menu",
+    "breadcrumb",
+    "tab",
+    "link",
+    "pagination",
+    "stepper",
+    "topbar"
+  ],
+  Feedback: [
+    "alert",
+    "toast",
+    "notification",
+    "message",
+    "badge",
+    "indicator",
+    "progress",
+    "spinner",
+    "loading",
+    "loader",
+    "lozenge",
+    "chip"
+  ],
+  "Data Display": [
+    "table",
+    "list",
+    "card",
+    "avatar",
+    "stat",
+    "timeline",
+    "tree",
+    "datalist",
+    "datacard"
+  ],
+  Overlays: [
+    "modal",
+    "dialog",
+    "drawer",
+    "popover",
+    "tooltip",
+    "dropdown",
+    "slidepanel"
+  ],
+  Typography: ["text", "heading", "title", "label", "paragraph"],
+  Media: ["image", "video", "icon", "carousel"]
+};
+function inferCategoryFromMeta(componentName, props) {
+  const lower = componentName.toLowerCase();
+  for (const [category, patterns] of Object.entries(CATEGORY_PATTERNS)) {
+    for (const pattern of patterns) {
+      if (lower.includes(pattern)) {
+        return category;
+      }
+    }
+  }
+  const propNames = new Set(Object.keys(props));
+  if (propNames.has("onClick") || propNames.has("onPress")) return "Actions";
+  if (propNames.has("value") || propNames.has("defaultValue")) return "Forms";
+  if (propNames.has("children")) return "Layout";
+  return "Components";
+}
+function inferStatus(filePath) {
+  const lowerPath = filePath.toLowerCase();
+  if (lowerPath.includes("/experimental/") || lowerPath.includes("/labs/"))
+    return "experimental";
+  if (lowerPath.includes("/beta/")) return "beta";
+  if (lowerPath.includes("/deprecated/") || lowerPath.includes("/legacy/"))
+    return "deprecated";
+  if (lowerPath.includes("/draft/") || lowerPath.includes("/wip/"))
+    return "draft";
+  return "stable";
+}
+function inferDescriptionFromMeta(componentName, props) {
+  const words = componentName.replace(/([A-Z])/g, " $1").trim().toLowerCase();
+  const propNames = new Set(Object.keys(props));
+  const hasOnClick = propNames.has("onClick") || propNames.has("onPress");
+  const hasValue = propNames.has("value") || propNames.has("defaultValue");
+  const hasChildren = propNames.has("children");
+  if (hasOnClick && !hasValue)
+    return `Interactive ${words} element for triggering actions`;
+  if (hasValue) return `Form ${words} for user input`;
+  if (hasChildren) return `Container ${words} for grouping content`;
+  return `${words.charAt(0).toUpperCase() + words.slice(1)} component`;
+}
+function inferAccessibilityFromMeta(props) {
+  const propNames = new Set(Object.keys(props));
+  const accessibility = {};
+  const hasOnClick = propNames.has("onClick") || propNames.has("onPress");
+  const hasAriaLabel = propNames.has("ariaLabel") || propNames.has("aria-label");
+  const hasDisabled = propNames.has("disabled");
+  const hasHref = propNames.has("href");
+  if (hasOnClick && !hasHref) accessibility.role = "button";
+  else if (hasHref) accessibility.role = "link";
+  const requirements = [];
+  if (hasOnClick && !hasAriaLabel)
+    requirements.push("Should have visible text or aria-label");
+  if (hasDisabled)
+    requirements.push(
+      "Disabled state should be conveyed to assistive technology"
+    );
+  if (requirements.length > 0) accessibility.requirements = requirements;
+  return accessibility;
+}
+function buildContractBlock(componentName, props, composition, accessibility) {
+  const localEntries = Object.entries(props).filter(([_, p]) => p.source === "local");
+  if (localEntries.length === 0 && !composition && !accessibility.requirements?.length) {
+    return null;
+  }
+  const contract = { propsSummary: [] };
+  for (const [name, prop] of localEntries) {
+    let summary = name + ": ";
+    if (prop.typeKind === "enum" && prop.values && prop.values.length > 0) {
+      summary += prop.values.join(" | ");
+    } else {
+      summary += prop.typeKind;
+    }
+    if (prop.required) summary += " (required)";
+    if (prop.default !== void 0) summary += ` (default: ${prop.default})`;
+    contract.propsSummary.push(summary);
+  }
+  if (composition && composition.parts.length > 0) {
+    const children = {};
+    for (const part of composition.parts) {
+      const childEntry = {};
+      if (composition.required.includes(part.name)) {
+        childEntry.required = true;
+      }
+      const nodeProps = Object.entries(part.props).filter(([_, p]) => p.typeKind === "node" || p.typeKind === "element").map(([n]) => n);
+      if (nodeProps.length > 0) {
+        childEntry.accepts = nodeProps;
+      }
+      children[part.name] = childEntry;
+    }
+    contract.compoundChildren = children;
+  }
+  if (composition && composition.parts.length > 0) {
+    const innerLines = composition.parts.map((part) => `  <${componentName}.${part.name}>...</${componentName}.${part.name}>`).join("\n");
+    contract.canonicalUsage = [
+      `<${componentName}>
+${innerLines}
+</${componentName}>`
+    ];
+  }
+  const rules = [];
+  if (accessibility.role) {
+    rules.push(`Role: ${accessibility.role}`);
+  }
+  if (accessibility.requirements) {
+    rules.push(...accessibility.requirements);
+  }
+  if (rules.length > 0) {
+    contract.a11yRules = rules;
+  }
+  return contract;
+}
+function emitContractBlock(contract) {
+  const lines = [];
+  lines.push("\n  contract: {");
+  if (contract.propsSummary.length > 0) {
+    lines.push("    propsSummary: [");
+    for (const s of contract.propsSummary) {
+      lines.push(`      '${escapeQuotes(s)}',`);
+    }
+    lines.push("    ],");
+  }
+  if (contract.compoundChildren && Object.keys(contract.compoundChildren).length > 0) {
+    lines.push("    compoundChildren: {");
+    for (const [name, meta] of Object.entries(contract.compoundChildren)) {
+      const fields = [];
+      if (meta.required) fields.push(`required: true`);
+      if (meta.accepts && meta.accepts.length > 0) {
+        fields.push(`accepts: [${meta.accepts.map((a) => `'${a}'`).join(", ")}]`);
+      }
+      if (meta.description) fields.push(`description: '${escapeQuotes(meta.description)}'`);
+      lines.push(`      ${name}: { ${fields.join(", ")} },`);
+    }
+    lines.push("    },");
+  }
+  if (contract.canonicalUsage && contract.canonicalUsage.length > 0) {
+    lines.push("    canonicalUsage: [");
+    for (const usage of contract.canonicalUsage) {
+      lines.push(`      \`${usage}\`,`);
+    }
+    lines.push("    ],");
+  }
+  if (contract.a11yRules && contract.a11yRules.length > 0) {
+    lines.push("    a11yRules: [");
+    for (const rule of contract.a11yRules) {
+      lines.push(`      '${escapeQuotes(rule)}',`);
+    }
+    lines.push("    ],");
+  }
+  if (contract.scenarioTags && contract.scenarioTags.length > 0) {
+    lines.push("    scenarioTags: [");
+    for (const tag of contract.scenarioTags) {
+      lines.push(`      '${escapeQuotes(tag)}',`);
+    }
+    lines.push("    ],");
+  }
+  lines.push("  },");
+  return lines.join("\n");
+}
+function computeImportPath(fragmentDir, sourcePath, componentBaseName) {
+  const sourceDir = dirname(sourcePath);
+  if (fragmentDir === sourceDir) {
+    if (componentBaseName === "index") {
+      return ".";
+    }
+    return `./${componentBaseName}`;
+  }
+  let rel = relative(fragmentDir, sourceDir);
+  if (!rel.startsWith(".")) rel = `./${rel}`;
+  if (componentBaseName !== "index") {
+    rel = `${rel}/${componentBaseName}`;
+  }
+  return rel;
+}
+function escapeQuotes(str) {
+  return str.replace(/'/g, "\\'");
+}
+function generateFragmentWithTodos(componentName, importPath, data, confidence, enrichment) {
+  const props = data.meta?.props ?? {};
+  const localProps = Object.fromEntries(
+    Object.entries(props).filter(([_, p]) => p.source === "local")
+  );
+  const composition = data.meta?.composition ?? null;
+  const description = data.meta?.description || inferDescriptionFromMeta(componentName, localProps);
+  const descriptionTodo = data.meta?.description ? "" : " // TODO: Review description";
+  const category = inferCategoryFromMeta(componentName, localProps);
+  const categoryTodo = category === "Components" ? " // TODO: Set correct category" : "";
+  const status = inferStatus(data.component.sourcePath);
+  const accessibility = inferAccessibilityFromMeta(localProps);
+  const propsBlock = buildPropsBlockFromMeta(props);
+  const contract = buildContractBlock(componentName, props, composition, accessibility);
+  if (contract && enrichment) {
+    if (enrichment.a11yRules.length > 0) {
+      contract.a11yRules = enrichment.a11yRules;
+    }
+    if (enrichment.scenarioTags.length > 0) {
+      contract.scenarioTags = enrichment.scenarioTags;
+    }
+  }
+  const contractBlock = contract ? emitContractBlock(contract) : "";
+  let usageBlock;
+  if (enrichment && (enrichment.when.length > 0 || enrichment.whenNot.length > 0)) {
+    usageBlock = buildEnrichedUsageBlock(enrichment);
+  } else {
+    usageBlock = `  usage: {
+    when: [
+      // TODO: Describe when to use ${componentName}
+    ],
+    whenNot: [
+      // TODO: Describe when NOT to use ${componentName}
+    ],
+  },`;
+  }
+  const tagsLine = enrichment && enrichment.tags.length > 0 ? `
+    tags: [${enrichment.tags.map((t) => `'${escapeQuotes(t)}'`).join(", ")}],` : "";
+  const variantsBlock = buildVariantsBlock(
+    componentName,
+    data.storyVariants,
+    composition
+  );
+  const aiBlock = buildAIBlock(composition);
+  const provenanceBlock = buildProvenanceBlock(confidence, props);
+  const compoundComment = composition && composition.parts.length > 0 ? `
+// Compound sub-components detected: ${composition.parts.map((p) => p.name).join(", ")}` : "";
+  return `// Auto-generated by fragments init --scan | Confidence: ${confidence.score}/100
+// ${confidence.todoFields.length} TODO(s) \u2014 search for "TODO:" and fill in human knowledge${compoundComment}
+import React from 'react';
+import { defineFragment } from '@fragments-sdk/core';
+import { ${componentName} } from '${importPath}';
+
+export default defineFragment({
+  component: ${componentName},
+
+  meta: {
+    name: '${escapeQuotes(componentName)}',
+    description: '${escapeQuotes(description)}',${descriptionTodo}
+    category: '${escapeQuotes(category)}',${categoryTodo}
+    status: '${status}',${tagsLine}
+  },
+
+${usageBlock}
+
+  props: ${propsBlock},${contractBlock}${aiBlock}
+
+  variants: [
+${variantsBlock}
+  ],
+${provenanceBlock}});
+`;
+}
+function buildPropsBlockFromMeta(props) {
+  const entries = Object.entries(props).filter(([_, p]) => p.source === "local");
+  if (entries.length === 0) return "{}";
+  const lines = entries.map(([name, prop]) => {
+    const type = prop.typeKind;
+    const parts = [`      type: '${type}'`];
+    if (prop.description) {
+      parts.push(
+        `      description: '${escapeQuotes(prop.description.replace(/\n/g, " "))}'`
+      );
+    }
+    parts.push(`      required: ${prop.required}`);
+    if (prop.default !== void 0) {
+      parts.push(`      default: ${JSON.stringify(prop.default)}`);
+    }
+    if (prop.values && prop.values.length > 0) {
+      parts.push(`      values: ${JSON.stringify(prop.values)}`);
+    }
+    const todoComment = type === "custom" ? " // TODO: Review type" : "";
+    return `    ${name}: {
+${parts.join(",\n")},
+    },${todoComment}`;
+  });
+  return `{
+${lines.join("\n")}
+  }`;
+}
+function buildVariantsBlock(componentName, storyVariants, composition) {
+  const entries = [];
+  const hasDefault = storyVariants.some((v) => v.name === "Default");
+  if (!hasDefault) {
+    if (composition && composition.pattern === "compound" && composition.parts.length > 0) {
+      entries.push(formatCompoundVariantEntry(componentName, composition));
+    } else {
+      entries.push(formatVariantEntry(componentName, "Default", `Default ${componentName}`, {}));
+    }
+  }
+  for (const variant of storyVariants) {
+    const description = variant.name.replace(/([A-Z])/g, " $1").trim();
+    entries.push(
+      formatVariantEntry(
+        componentName,
+        variant.name,
+        `${description} ${componentName}`,
+        variant.args
+      )
+    );
+  }
+  return entries.join("\n");
+}
+function formatVariantEntry(componentName, name, description, args) {
+  const jsxCode = buildJsxString(componentName, args);
+  return `    {
+      name: '${escapeQuotes(name)}',
+      description: '${escapeQuotes(description)}',
+      code: \`${jsxCode}\`,
+      render: () => ${jsxCode},
+    },`;
+}
+function formatCompoundVariantEntry(componentName, composition) {
+  const parts = composition.parts;
+  const innerJsx = parts.map((part) => `    <${componentName}.${part.name}>...</${componentName}.${part.name}>`).join("\n");
+  const jsxCode = `<${componentName}>
+${innerJsx}
+  </${componentName}>`;
+  return `    {
+      name: 'Default',
+      description: 'Default ${componentName} with sub-components',
+      code: \`${jsxCode}\`,
+      render: () => (
+        ${jsxCode}
+      ),
+    },`;
+}
+function buildAIBlock(composition) {
+  if (!composition || composition.parts.length === 0) return "";
+  const subComponents = composition.parts.map((p) => `'${p.name}'`).join(", ");
+  const pattern = `
+      <Component>
+${composition.parts.map((p) => `        <Component.${p.name}>...</Component.${p.name}>`).join("\n")}
+      </Component>`;
+  return `
+
+  ai: {
+    compositionPattern: '${composition.pattern}',
+    subComponents: [${subComponents}],
+    commonPatterns: [\`${pattern}
+    \`],
+  },`;
+}
+function buildProvenanceBlock(confidence, props) {
+  const autoFields = Object.keys(props).filter((name) => props[name].source === "local");
+  return `
+  _generated: {
+    source: 'ai',
+    confidence: ${(confidence.score / 100).toFixed(2)},
+    timestamp: '${(/* @__PURE__ */ new Date()).toISOString()}',
+  },
+`;
+}
+function buildJsxString(componentName, args) {
+  const { children, ...restArgs } = args;
+  const propParts = [];
+  for (const [key, value] of Object.entries(restArgs)) {
+    if (typeof value === "string") {
+      propParts.push(`${key}="${escapeQuotes(value)}"`);
+    } else if (typeof value === "boolean") {
+      propParts.push(value ? key : `${key}={false}`);
+    } else if (typeof value === "number") {
+      propParts.push(`${key}={${value}}`);
+    }
+  }
+  const propsStr = propParts.length > 0 ? " " + propParts.join(" ") : "";
+  if (typeof children === "string") {
+    return `<${componentName}${propsStr}>${children}</${componentName}>`;
+  }
+  return `<${componentName}${propsStr} />`;
+}
+export {
+  buildEnrichedUsageBlock,
+  buildEnrichmentSystemPrompt,
+  buildEnrichmentUserPrompt,
+  calculateFieldConfidence,
+  detectCompoundComponents,
+  detectCompoundComponentsFromSource,
+  extractComponentJSDoc,
+  extractComponentJSDocFromSource,
+  parseEnrichmentResponse,
+  scanGenerate
+};
+//# sourceMappingURL=scan-generate-SYU4PYZD.js.map