@fragments-sdk/cli 0.14.2 → 0.15.0

package/dist/chunk-QCN35LJU.js

@@ -0,0 +1,630 @@
+import { createRequire as __banner_createRequire } from 'module'; const require = __banner_createRequire(import.meta.url);
+import {
+  scanFile
+} from "./chunk-7DZC4YEV.js";
+
+// src/service/enhance/codebase-scanner.ts
+import fg from "fast-glob";
+import { readFile as readFile2 } from "fs/promises";
+import { relative, resolve, dirname as dirname2 } from "path";
+
+// src/service/enhance/aggregator.ts
+function aggregateComponentUsages(componentName, sourceFile, usages, imports) {
+  const uniqueFiles = new Set(usages.map((u) => u.filePath));
+  const patternMap = /* @__PURE__ */ new Map();
+  for (const usage of usages) {
+    const propKey = createPropKey(usage.props.static);
+    const existing = patternMap.get(propKey);
+    if (existing) {
+      existing.count++;
+      if (!existing.files.includes(usage.filePath)) {
+        existing.files.push(usage.filePath);
+      }
+      if (existing.sampleContexts.length < 3) {
+        existing.sampleContexts.push(usage.context);
+      }
+    } else {
+      patternMap.set(propKey, {
+        props: { ...usage.props.static },
+        count: 1,
+        files: [usage.filePath],
+        sampleContexts: [usage.context]
+      });
+    }
+  }
+  const patterns = Array.from(patternMap.values()).sort(
+    (a, b) => b.count - a.count
+  );
+  const contextMap = /* @__PURE__ */ new Map();
+  for (const usage of usages) {
+    const context = classifyFileContext(usage.filePath, usage.context);
+    const existing = contextMap.get(context);
+    if (existing) {
+      existing.count++;
+      if (!existing.files.includes(usage.filePath)) {
+        existing.files.push(usage.filePath);
+      }
+    } else {
+      contextMap.set(context, { count: 1, files: [usage.filePath] });
+    }
+  }
+  const contexts = Array.from(contextMap.entries()).map(([type, data]) => ({ type, ...data })).sort((a, b) => b.count - a.count);
+  return {
+    name: componentName,
+    sourceFile,
+    totalUsages: usages.length,
+    uniqueFiles: uniqueFiles.size,
+    patterns,
+    contexts,
+    usages,
+    imports
+  };
+}
+function aggregateAllUsages(usages, imports, componentSources) {
+  const usagesByComponent = /* @__PURE__ */ new Map();
+  for (const usage of usages) {
+    const existing = usagesByComponent.get(usage.componentName) ?? [];
+    existing.push(usage);
+    usagesByComponent.set(usage.componentName, existing);
+  }
+  const importsByComponent = /* @__PURE__ */ new Map();
+  for (const imp of imports) {
+    const existing = importsByComponent.get(imp.componentName) ?? [];
+    existing.push(imp);
+    importsByComponent.set(imp.componentName, existing);
+  }
+  const components = {};
+  const allComponentNames = /* @__PURE__ */ new Set([
+    ...usagesByComponent.keys(),
+    ...importsByComponent.keys()
+  ]);
+  for (const componentName of allComponentNames) {
+    const componentUsages = usagesByComponent.get(componentName) ?? [];
+    const componentImports = importsByComponent.get(componentName) ?? [];
+    const sourceFile = componentSources.get(componentName) ?? "unknown";
+    components[componentName] = aggregateComponentUsages(
+      componentName,
+      sourceFile,
+      componentUsages,
+      componentImports
+    );
+  }
+  const allFiles = /* @__PURE__ */ new Set();
+  for (const usage of usages) {
+    allFiles.add(usage.filePath);
+  }
+  for (const imp of imports) {
+    allFiles.add(imp.filePath);
+  }
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    rootDir: "",
+    // Will be set by caller
+    totalFiles: allFiles.size,
+    totalComponents: Object.keys(components).length,
+    components,
+    errorFiles: []
+    // Will be populated by scanner
+  };
+}
+function createPropKey(props) {
+  const entries = Object.entries(props).sort(([a], [b]) => a.localeCompare(b));
+  return entries.map(([k, v]) => `${k}=${JSON.stringify(v)}`).join("|");
+}
+function classifyFileContext(filePath, context) {
+  const lowerPath = filePath.toLowerCase();
+  const lowerContext = context.toLowerCase();
+  if (lowerPath.includes("/modal") || lowerPath.includes("modal.") || lowerContext.includes("<modal")) {
+    return "modal";
+  }
+  if (lowerPath.includes("/dialog") || lowerPath.includes("dialog.") || lowerContext.includes("<dialog")) {
+    return "dialog";
+  }
+  if (lowerPath.includes("/form") || lowerPath.includes("form.") || lowerContext.includes("<form") || lowerContext.includes("onsubmit")) {
+    return "form";
+  }
+  if (lowerPath.includes("/page") || lowerPath.includes("pages/") || lowerPath.includes("/routes/")) {
+    return "page";
+  }
+  if (lowerPath.includes("/layout") || lowerPath.includes("layout.") || lowerPath.includes("/layouts/")) {
+    return "layout";
+  }
+  if (lowerPath.includes("/card") || lowerPath.includes("card.") || lowerContext.includes("<card")) {
+    return "card";
+  }
+  if (lowerPath.includes("/table") || lowerPath.includes("table.") || lowerContext.includes("<table") || lowerContext.includes("<tr")) {
+    return "table";
+  }
+  if (lowerPath.includes("/list") || lowerPath.includes("list.") || lowerContext.includes("<ul") || lowerContext.includes("<ol") || lowerContext.includes("<li")) {
+    return "list";
+  }
+  if (lowerPath.includes("/nav") || lowerPath.includes("navigation") || lowerContext.includes("<nav")) {
+    return "navigation";
+  }
+  if (lowerPath.includes("/header") || lowerPath.includes("header.") || lowerContext.includes("<header")) {
+    return "header";
+  }
+  if (lowerPath.includes("/footer") || lowerPath.includes("footer.") || lowerContext.includes("<footer")) {
+    return "footer";
+  }
+  if (lowerPath.includes("/sidebar") || lowerPath.includes("sidebar.") || lowerContext.includes("<aside")) {
+    return "sidebar";
+  }
+  return "unknown";
+}
+function findCommonPropCombinations(usages, minOccurrences = 3) {
+  const combinations = /* @__PURE__ */ new Map();
+  for (const usage of usages) {
+    const allProps = [
+      ...Object.keys(usage.props.static),
+      ...usage.props.dynamic
+    ].sort();
+    for (let size = 2; size <= Math.min(allProps.length, 4); size++) {
+      for (const combo of combinations_k(allProps, size)) {
+        const key = combo.join(",");
+        combinations.set(key, (combinations.get(key) ?? 0) + 1);
+      }
+    }
+  }
+  return Array.from(combinations.entries()).filter(([, count]) => count >= minOccurrences).map(([key, count]) => ({ props: key.split(","), count })).sort((a, b) => b.count - a.count);
+}
+function* combinations_k(arr, k) {
+  if (k === 0) {
+    yield [];
+    return;
+  }
+  if (arr.length < k) return;
+  for (let i = 0; i <= arr.length - k; i++) {
+    for (const combo of combinations_k(arr.slice(i + 1), k - 1)) {
+      yield [arr[i], ...combo];
+    }
+  }
+}
+function inferRelations(componentName, analysis, allAnalyses) {
+  const relations = [];
+  const parentCounts = /* @__PURE__ */ new Map();
+  const siblingCounts = /* @__PURE__ */ new Map();
+  for (const usage of analysis.usages) {
+    if (usage.parentElement && usage.parentElement !== "div" && usage.parentElement !== "span") {
+      const parent = usage.parentElement;
+      const existing = parentCounts.get(parent);
+      if (existing) {
+        existing.count++;
+        if (!existing.files.includes(usage.filePath)) {
+          existing.files.push(usage.filePath);
+        }
+      } else {
+        parentCounts.set(parent, { count: 1, files: [usage.filePath] });
+      }
+    }
+  }
+  const filesWithThisComponent = new Set(analysis.usages.map((u) => u.filePath));
+  for (const [otherName, otherAnalysis] of Object.entries(allAnalyses)) {
+    if (otherName === componentName) continue;
+    let sharedFiles = 0;
+    const sharedFileList = [];
+    for (const usage of otherAnalysis.usages) {
+      if (filesWithThisComponent.has(usage.filePath)) {
+        if (!sharedFileList.includes(usage.filePath)) {
+          sharedFiles++;
+          sharedFileList.push(usage.filePath);
+        }
+      }
+    }
+    if (sharedFiles >= 3) {
+      siblingCounts.set(otherName, {
+        count: sharedFiles,
+        files: sharedFileList.slice(0, 5)
+      });
+    }
+  }
+  for (const [parent, data] of parentCounts) {
+    if (data.count >= 2) {
+      relations.push({
+        component: parent,
+        relationship: "parent",
+        frequency: data.count,
+        sampleFiles: data.files.slice(0, 3)
+      });
+    }
+  }
+  for (const [sibling, data] of siblingCounts) {
+    relations.push({
+      component: sibling,
+      relationship: "sibling",
+      frequency: data.count,
+      sampleFiles: data.files.slice(0, 3)
+    });
+  }
+  relations.sort((a, b) => b.frequency - a.frequency);
+  return relations;
+}
+function inferAllRelations(analysis) {
+  const allRelations = /* @__PURE__ */ new Map();
+  for (const [componentName, componentAnalysis] of Object.entries(analysis.components)) {
+    const relations = inferRelations(componentName, componentAnalysis, analysis.components);
+    if (relations.length > 0) {
+      allRelations.set(componentName, relations);
+    }
+  }
+  return allRelations;
+}
+function summarizePatternsForPrompt(analysis, maxPatterns = 10, maxContexts = 5) {
+  const lines = [];
+  lines.push(`## ${analysis.name}`);
+  lines.push(`Total usages: ${analysis.totalUsages} across ${analysis.uniqueFiles} files`);
+  lines.push("");
+  lines.push("### Usage Patterns (by frequency)");
+  const topPatterns = analysis.patterns.slice(0, maxPatterns);
+  for (const pattern of topPatterns) {
+    const propsStr = Object.entries(pattern.props).map(([k, v]) => `${k}=${JSON.stringify(v)}`).join(", ");
+    lines.push(`- ${propsStr || "(no props)"}: ${pattern.count} usages in ${pattern.files.length} files`);
+  }
+  lines.push("");
+  lines.push("### File Contexts");
+  const topContexts = analysis.contexts.slice(0, maxContexts);
+  for (const ctx of topContexts) {
+    lines.push(`- ${ctx.type}: ${ctx.count} usages`);
+  }
+  lines.push("");
+  lines.push("### Sample Usages");
+  for (const pattern of topPatterns.slice(0, 3)) {
+    if (pattern.sampleContexts[0]) {
+      lines.push("```tsx");
+      lines.push(pattern.sampleContexts[0].trim());
+      lines.push("```");
+      lines.push("");
+    }
+  }
+  return lines.join("\n");
+}
+
+// src/service/enhance/cache.ts
+import { readFile, writeFile } from "fs/promises";
+import { existsSync } from "fs";
+import { createHash } from "crypto";
+import { join, dirname } from "path";
+import { mkdir } from "fs/promises";
+var CURRENT_CACHE_VERSION = 1;
+var CACHE_FILENAME = "analysis-cache.json";
+function getCachePath(rootDir) {
+  return join(rootDir, ".fragments", CACHE_FILENAME);
+}
+async function loadCache(rootDir) {
+  const cachePath = getCachePath(rootDir);
+  if (!existsSync(cachePath)) {
+    return null;
+  }
+  try {
+    const content = await readFile(cachePath, "utf-8");
+    const cache = JSON.parse(content);
+    if (cache.version !== CURRENT_CACHE_VERSION) {
+      console.warn(
+        `Cache version mismatch: expected ${CURRENT_CACHE_VERSION}, got ${cache.version}. Invalidating cache.`
+      );
+      return null;
+    }
+    if (cache.rootDir !== rootDir) {
+      console.warn(`Cache root mismatch. Invalidating cache.`);
+      return null;
+    }
+    return cache;
+  } catch (error) {
+    console.warn(`Failed to load cache: ${error.message}`);
+    return null;
+  }
+}
+async function saveCache(rootDir, cache) {
+  const cachePath = getCachePath(rootDir);
+  const cacheDir = dirname(cachePath);
+  if (!existsSync(cacheDir)) {
+    await mkdir(cacheDir, { recursive: true });
+  }
+  cache.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeFile(cachePath, JSON.stringify(cache, null, 2));
+}
+function createEmptyCache(rootDir) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    version: CURRENT_CACHE_VERSION,
+    createdAt: now,
+    updatedAt: now,
+    rootDir,
+    files: {}
+  };
+}
+function computeFileHash(content) {
+  return createHash("md5").update(content).digest("hex");
+}
+function getCachedFile(cache, filePath) {
+  return cache.files[filePath] ?? null;
+}
+function updateCacheFile(cache, filePath, hash, imports, usages) {
+  cache.files[filePath] = {
+    hash,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    imports,
+    usages
+  };
+}
+function removeCacheFile(cache, filePath) {
+  delete cache.files[filePath];
+}
+async function detectFileChanges(cache, currentFiles, getFileHash) {
+  const changes = {
+    added: [],
+    modified: [],
+    deleted: [],
+    unchanged: []
+  };
+  const currentFileSet = new Set(currentFiles);
+  const cachedFileSet = new Set(Object.keys(cache.files));
+  for (const filePath of currentFiles) {
+    const entry = cache.files[filePath];
+    if (!entry) {
+      changes.added.push(filePath);
+    } else {
+      const currentHash = await getFileHash(filePath);
+      if (currentHash !== entry.hash) {
+        changes.modified.push(filePath);
+      } else {
+        changes.unchanged.push(filePath);
+      }
+    }
+  }
+  for (const cachedFile of cachedFileSet) {
+    if (!currentFileSet.has(cachedFile)) {
+      changes.deleted.push(cachedFile);
+    }
+  }
+  return changes;
+}
+function getCacheStats(cache) {
+  let totalImports = 0;
+  let totalUsages = 0;
+  for (const entry of Object.values(cache.files)) {
+    totalImports += entry.imports.length;
+    totalUsages += entry.usages.length;
+  }
+  const ageMs = Date.now() - new Date(cache.updatedAt).getTime();
+  const ageMinutes = Math.round(ageMs / 6e4);
+  const cacheAge = ageMinutes < 60 ? `${ageMinutes} minutes ago` : ageMinutes < 1440 ? `${Math.round(ageMinutes / 60)} hours ago` : `${Math.round(ageMinutes / 1440)} days ago`;
+  return {
+    totalFiles: Object.keys(cache.files).length,
+    totalImports,
+    totalUsages,
+    cacheAge
+  };
+}
+
+// src/service/enhance/codebase-scanner.ts
+var DEFAULT_INCLUDE = [
+  "**/*.tsx",
+  "**/*.ts",
+  "**/*.jsx",
+  "**/*.js"
+];
+var DEFAULT_EXCLUDE = [
+  "**/node_modules/**",
+  "**/dist/**",
+  "**/build/**",
+  "**/.next/**",
+  "**/coverage/**",
+  "**/__tests__/**",
+  "**/*.test.*",
+  "**/*.spec.*",
+  "**/*.stories.*",
+  "**/*.fragment.*",
+  "**/storybook-static/**"
+];
+async function scanCodebase(options) {
+  const {
+    rootDir,
+    include = DEFAULT_INCLUDE,
+    exclude = DEFAULT_EXCLUDE,
+    componentNames,
+    useCache = true,
+    onProgress
+  } = options;
+  const absoluteRoot = resolve(rootDir);
+  let cache = null;
+  if (useCache) {
+    cache = await loadCache(absoluteRoot);
+  }
+  if (!cache) {
+    cache = createEmptyCache(absoluteRoot);
+  }
+  onProgress?.({
+    current: 0,
+    total: 0,
+    currentFile: "",
+    phase: "discovering"
+  });
+  const files = await fg(include, {
+    cwd: absoluteRoot,
+    ignore: exclude,
+    absolute: true,
+    onlyFiles: true
+  });
+  const totalFiles = files.length;
+  const trackedComponents = componentNames ? new Set(componentNames) : void 0;
+  const allImports = [];
+  const allUsages = [];
+  const errorFiles = [];
+  const componentSources = /* @__PURE__ */ new Map();
+  for (let i = 0; i < files.length; i++) {
+    const filePath = files[i];
+    const relativePath = relative(absoluteRoot, filePath);
+    onProgress?.({
+      current: i + 1,
+      total: totalFiles,
+      currentFile: relativePath,
+      phase: "scanning"
+    });
+    try {
+      const content = await readFile2(filePath, "utf-8");
+      const fileHash = computeFileHash(content);
+      const cachedEntry = getCachedFile(cache, filePath);
+      if (cachedEntry && cachedEntry.hash === fileHash) {
+        allImports.push(...cachedEntry.imports);
+        allUsages.push(...cachedEntry.usages);
+        for (const imp of cachedEntry.imports) {
+          if (!componentSources.has(imp.componentName)) {
+            const sourceFile = resolveImportSource(filePath, imp.source);
+            if (sourceFile) {
+              componentSources.set(imp.componentName, sourceFile);
+            }
+          }
+        }
+        continue;
+      }
+      const { imports, usages } = await scanFile(filePath, trackedComponents);
+      updateCacheFile(cache, filePath, fileHash, imports, usages);
+      allImports.push(...imports);
+      allUsages.push(...usages);
+      for (const imp of imports) {
+        if (!componentSources.has(imp.componentName)) {
+          const sourceFile = resolveImportSource(filePath, imp.source);
+          if (sourceFile) {
+            componentSources.set(imp.componentName, sourceFile);
+          }
+        }
+      }
+    } catch (error) {
+      errorFiles.push(relativePath);
+      console.warn(`Error scanning ${relativePath}:`, error.message);
+    }
+  }
+  if (useCache) {
+    await saveCache(absoluteRoot, cache);
+  }
+  onProgress?.({
+    current: totalFiles,
+    total: totalFiles,
+    currentFile: "",
+    phase: "aggregating"
+  });
+  const analysis = aggregateAllUsages(allUsages, allImports, componentSources);
+  analysis.rootDir = absoluteRoot;
+  analysis.totalFiles = totalFiles;
+  analysis.errorFiles = errorFiles;
+  return analysis;
+}
+async function incrementalScan(rootDir, changes, existingCache, onProgress) {
+  const absoluteRoot = resolve(rootDir);
+  const cache = { ...existingCache, files: { ...existingCache.files } };
+  for (const filePath of changes.deleted) {
+    removeCacheFile(cache, filePath);
+  }
+  const filesToScan = [...changes.added, ...changes.modified];
+  const totalFiles = filesToScan.length;
+  const allImports = [];
+  const allUsages = [];
+  const errorFiles = [];
+  const componentSources = /* @__PURE__ */ new Map();
+  for (const filePath of changes.unchanged) {
+    const cachedEntry = getCachedFile(cache, filePath);
+    if (cachedEntry) {
+      allImports.push(...cachedEntry.imports);
+      allUsages.push(...cachedEntry.usages);
+      for (const imp of cachedEntry.imports) {
+        if (!componentSources.has(imp.componentName)) {
+          const sourceFile = resolveImportSource(filePath, imp.source);
+          if (sourceFile) {
+            componentSources.set(imp.componentName, sourceFile);
+          }
+        }
+      }
+    }
+  }
+  for (let i = 0; i < filesToScan.length; i++) {
+    const filePath = filesToScan[i];
+    const relativePath = relative(absoluteRoot, filePath);
+    onProgress?.({
+      current: i + 1,
+      total: totalFiles,
+      currentFile: relativePath,
+      phase: "scanning"
+    });
+    try {
+      const content = await readFile2(filePath, "utf-8");
+      const fileHash = computeFileHash(content);
+      const { imports, usages } = await scanFile(filePath);
+      updateCacheFile(cache, filePath, fileHash, imports, usages);
+      allImports.push(...imports);
+      allUsages.push(...usages);
+      for (const imp of imports) {
+        if (!componentSources.has(imp.componentName)) {
+          const sourceFile = resolveImportSource(filePath, imp.source);
+          if (sourceFile) {
+            componentSources.set(imp.componentName, sourceFile);
+          }
+        }
+      }
+    } catch (error) {
+      errorFiles.push(relativePath);
+    }
+  }
+  await saveCache(absoluteRoot, cache);
+  const analysis = aggregateAllUsages(allUsages, allImports, componentSources);
+  analysis.rootDir = absoluteRoot;
+  analysis.totalFiles = changes.unchanged.length + filesToScan.length;
+  analysis.errorFiles = errorFiles;
+  return { analysis, cache };
+}
+function resolveImportSource(importingFile, source) {
+  if (!source.startsWith(".") && !source.startsWith("/")) {
+    return null;
+  }
+  const importDir = dirname2(importingFile);
+  const extensions = ["", ".tsx", ".ts", ".jsx", ".js", "/index.tsx", "/index.ts"];
+  for (const ext of extensions) {
+    const fullPath = resolve(importDir, source + ext);
+    if (ext === "" && source.endsWith(".tsx")) {
+      return fullPath;
+    }
+    if (ext) {
+      return resolve(importDir, source) + ext;
+    }
+  }
+  return resolve(importDir, source);
+}
+function getScanStats(analysis) {
+  const totalUsages = Object.values(analysis.components).reduce(
+    (sum, c) => sum + c.totalUsages,
+    0
+  );
+  const topComponents = Object.values(analysis.components).map((c) => ({ name: c.name, usages: c.totalUsages })).sort((a, b) => b.usages - a.usages).slice(0, 10);
+  return {
+    totalFiles: analysis.totalFiles,
+    totalComponents: analysis.totalComponents,
+    totalUsages,
+    topComponents
+  };
+}
+async function hasCachedAnalysis(rootDir) {
+  const cache = await loadCache(resolve(rootDir));
+  if (!cache) return false;
+  const stats = getCacheStats(cache);
+  return stats.totalFiles > 0;
+}
+
+export {
+  aggregateComponentUsages,
+  aggregateAllUsages,
+  findCommonPropCombinations,
+  inferRelations,
+  inferAllRelations,
+  summarizePatternsForPrompt,
+  loadCache,
+  saveCache,
+  createEmptyCache,
+  computeFileHash,
+  detectFileChanges,
+  getCacheStats,
+  scanCodebase,
+  incrementalScan,
+  getScanStats,
+  hasCachedAnalysis
+};
+//# sourceMappingURL=chunk-QCN35LJU.js.map