@agent-scope/manifest 1.0.1

package/dist/index.cjs

@@ -0,0 +1,731 @@
+'use strict';
+
+var path = require('path');
+var tsMorph = require('ts-morph');
+
+// src/parser.ts
+function collectCallExpressions(root) {
+  const results = [];
+  root.forEachDescendant((n) => {
+    if (tsMorph.Node.isCallExpression(n)) {
+      results.push(n);
+    }
+  });
+  return results;
+}
+function calleeText(callExpr) {
+  if (!tsMorph.Node.isCallExpression(callExpr)) return "";
+  return callExpr.getExpression().getText().trim();
+}
+var COMPLEX_STYLE_KEYS = /* @__PURE__ */ new Set([
+  "position",
+  "gridTemplate",
+  "gridTemplateColumns",
+  "gridTemplateRows",
+  "gridArea",
+  "gridColumn",
+  "gridRow",
+  "grid",
+  "animation",
+  "animationName",
+  "animationDuration",
+  "transition",
+  "transform",
+  "transformOrigin",
+  "clip",
+  "clipPath",
+  "willChange",
+  "contain"
+]);
+var COMPLEX_POSITION_VALUES = /* @__PURE__ */ new Set(["absolute", "fixed", "sticky"]);
+var COMPLEX_KEY_PREFIXES = ["grid", "animation", "transition"];
+function isComplexStyleKey(key) {
+  if (COMPLEX_STYLE_KEYS.has(key)) return true;
+  return COMPLEX_KEY_PREFIXES.some((p) => key.startsWith(p));
+}
+function hasCssComplexity(root) {
+  let complex = false;
+  root.forEachDescendant((n) => {
+    if (complex) return;
+    if (tsMorph.Node.isJsxAttribute(n)) {
+      const nameNode = n.getNameNode();
+      if (nameNode.getText() !== "style") return;
+      const initializer = n.getInitializer();
+      if (!initializer) return;
+      if (tsMorph.Node.isJsxExpression(initializer)) {
+        const inner = initializer.getExpression();
+        if (!inner || !tsMorph.Node.isObjectLiteralExpression(inner)) return;
+        for (const prop of inner.getProperties()) {
+          if (complex) break;
+          if (!tsMorph.Node.isPropertyAssignment(prop) && !tsMorph.Node.isShorthandPropertyAssignment(prop)) {
+            continue;
+          }
+          const keyText = prop.getNameNode().getText();
+          if (isComplexStyleKey(keyText)) {
+            complex = true;
+            break;
+          }
+          if (keyText === "position" && tsMorph.Node.isPropertyAssignment(prop)) {
+            const val = prop.getInitializer();
+            if (val) {
+              const raw = val.getText().replace(/['"]/g, "").trim().toLowerCase();
+              if (COMPLEX_POSITION_VALUES.has(raw)) {
+                complex = true;
+                break;
+              }
+            }
+          }
+        }
+      }
+      return;
+    }
+    if (tsMorph.Node.isTaggedTemplateExpression(n)) {
+      const tag = n.getTag().getText();
+      if (tag.startsWith("styled") || tag === "css" || tag === "keyframes") {
+        complex = true;
+      }
+      return;
+    }
+    if (tsMorph.Node.isJsxAttribute(n)) {
+      const nameNode = n.getNameNode();
+      if (nameNode.getText() !== "className") return;
+      const initializer = n.getInitializer();
+      if (!initializer) return;
+      if (tsMorph.Node.isJsxExpression(initializer)) {
+        const inner = initializer.getExpression();
+        if (inner && (tsMorph.Node.isIdentifier(inner) || tsMorph.Node.isCallExpression(inner) || tsMorph.Node.isPropertyAccessExpression(inner))) {
+          complex = true;
+        }
+      }
+    }
+  });
+  return complex;
+}
+function analyzeComplexity(bodyNode) {
+  return hasCssComplexity(bodyNode) ? "complex" : "simple";
+}
+var HOOK_REGEX = /^use[A-Z]/;
+function detectHooks(root) {
+  const names = /* @__PURE__ */ new Set();
+  collectCallExpressions(root).forEach((callExpr) => {
+    const callee = calleeText(callExpr);
+    const base = callee.split(".").pop() ?? callee;
+    if (HOOK_REGEX.test(base)) {
+      names.add(base);
+    }
+  });
+  return Array.from(names).sort();
+}
+function extractDirectContextNames(root) {
+  const names = /* @__PURE__ */ new Set();
+  collectCallExpressions(root).forEach((callExpr) => {
+    const callee = calleeText(callExpr);
+    const base = callee.split(".").pop() ?? callee;
+    if (base !== "useContext") return;
+    const args = (tsMorph.Node.isCallExpression(callExpr) ? callExpr : null)?.getArguments() ?? [];
+    const firstArg = args[0];
+    if (!firstArg) return;
+    const argText = firstArg.getText().trim();
+    if (argText) {
+      names.add(argText);
+    }
+  });
+  return Array.from(names);
+}
+function resolveHookContexts(hookName, importingFile, importSpecifier, project) {
+  const allFiles = project.getSourceFiles();
+  const importingDir = importingFile.getDirectoryPath();
+  const specParts = importSpecifier.replace(/^\.\.?\//, "");
+  const candidates = allFiles.filter((sf) => {
+    const fp = sf.getFilePath();
+    if (!fp.startsWith(importingDir.split("/src/")[0] ?? importingDir)) return false;
+    const basename = fp.split("/").pop() ?? "";
+    const specBase = specParts.split("/").pop() ?? specParts;
+    return basename === `${specBase}.ts` || basename === `${specBase}.tsx` || basename === `${specBase}.js` || basename === `${specBase}.jsx` || fp.endsWith(`${specParts}.ts`) || fp.endsWith(`${specParts}.tsx`) || fp.endsWith(`${importSpecifier}.ts`) || fp.endsWith(`${importSpecifier}.tsx`);
+  });
+  for (const candidate of candidates) {
+    const hookFunctions = [
+      ...candidate.getFunctions().filter((f) => f.getName() === hookName),
+      ...candidate.getVariableDeclarations().filter((v) => v.getName() === hookName)
+    ];
+    for (const fn of hookFunctions) {
+      const ctxNames = extractDirectContextNames(fn);
+      if (ctxNames.length > 0) return ctxNames;
+    }
+  }
+  return [];
+}
+function detectRequiredContexts(bodyNode, sourceFile, project) {
+  const contextNames = /* @__PURE__ */ new Set();
+  for (const name of extractDirectContextNames(bodyNode)) {
+    contextNames.add(name);
+  }
+  const hookedCalls = /* @__PURE__ */ new Set();
+  collectCallExpressions(bodyNode).forEach((callExpr) => {
+    const callee = calleeText(callExpr);
+    const base = callee.split(".").pop() ?? callee;
+    if (HOOK_REGEX.test(base) && base !== "useContext") {
+      hookedCalls.add(base);
+    }
+  });
+  if (hookedCalls.size === 0) {
+    return Array.from(contextNames).sort();
+  }
+  for (const importDecl of sourceFile.getImportDeclarations()) {
+    const specifier = importDecl.getModuleSpecifierValue();
+    if (!specifier.startsWith(".")) continue;
+    const namedImports = importDecl.getNamedImports();
+    for (const ni of namedImports) {
+      const hookName = ni.getName();
+      if (!hookedCalls.has(hookName)) continue;
+      const resolved = resolveHookContexts(hookName, sourceFile, specifier, project);
+      for (const ctx of resolved) {
+        contextNames.add(ctx);
+      }
+    }
+  }
+  return Array.from(contextNames).sort();
+}
+var FETCH_PATTERNS = [
+  /^fetch$/,
+  /^axios(\.[a-zA-Z]+)?$/,
+  /^useQuery$/,
+  /^useMutation$/,
+  /^useSWR$/,
+  /^useInfiniteQuery$/,
+  /^request$/
+];
+var TIMER_PATTERNS = [
+  /^setTimeout$/,
+  /^setInterval$/,
+  /^requestAnimationFrame$/,
+  /^clearTimeout$/,
+  /^clearInterval$/,
+  /^cancelAnimationFrame$/
+];
+var SUBSCRIPTION_PATTERNS = [
+  /\.subscribe$/,
+  /\.onSnapshot$/,
+  /\.on$/,
+  /\.listen$/,
+  /\.addListener$/
+];
+var GLOBAL_LISTENER_PATTERNS = [
+  /^window\.addEventListener$/,
+  /^document\.addEventListener$/,
+  /^window\.removeEventListener$/,
+  /^document\.removeEventListener$/
+];
+var BARE_ADD_EVENT_LISTENER = /^addEventListener$/;
+function matchesAny(text, patterns) {
+  return patterns.some((p) => p.test(text));
+}
+function detectSideEffects(root) {
+  const fetches = /* @__PURE__ */ new Set();
+  let timers = false;
+  const subscriptions = /* @__PURE__ */ new Set();
+  let globalListeners = false;
+  for (const callExpr of collectCallExpressions(root)) {
+    const callee = calleeText(callExpr);
+    if (matchesAny(callee, FETCH_PATTERNS)) {
+      const name = callee.split(".")[0] ?? callee;
+      fetches.add(name);
+      continue;
+    }
+    if (matchesAny(callee, TIMER_PATTERNS)) {
+      timers = true;
+      continue;
+    }
+    if (matchesAny(callee, GLOBAL_LISTENER_PATTERNS)) {
+      globalListeners = true;
+      continue;
+    }
+    if (matchesAny(callee, SUBSCRIPTION_PATTERNS)) {
+      const parts = callee.split(".");
+      const method = parts[parts.length - 1] ?? callee;
+      subscriptions.add(method);
+      continue;
+    }
+    if (BARE_ADD_EVENT_LISTENER.test(callee)) {
+      globalListeners = true;
+    }
+  }
+  root.forEachDescendant((n) => {
+    if (tsMorph.Node.isPropertyAccessExpression(n)) {
+      const text = n.getText();
+      if ((text.startsWith("window.") || text.startsWith("document.")) && (text.endsWith("addEventListener") || text.endsWith("removeEventListener"))) {
+        globalListeners = true;
+      }
+    }
+  });
+  return {
+    fetches: Array.from(fetches).sort(),
+    timers,
+    subscriptions: Array.from(subscriptions).sort(),
+    globalListeners
+  };
+}
+function propagateComplexity(components) {
+  const queue = [];
+  for (const [name, desc] of Object.entries(components)) {
+    if (desc.complexityClass === "complex") {
+      queue.push(name);
+    }
+  }
+  const visited = new Set(queue);
+  while (queue.length > 0) {
+    const current = queue.shift();
+    const desc = components[current];
+    if (!desc) continue;
+    for (const parentName of desc.composedBy) {
+      const parent = components[parentName];
+      if (!parent) continue;
+      parent.complexityClass = "complex";
+      if (!visited.has(parentName)) {
+        visited.add(parentName);
+        queue.push(parentName);
+      }
+    }
+  }
+}
+
+// src/parser.ts
+function isReactNode(typeName) {
+  return [
+    "ReactNode",
+    "ReactElement",
+    "JSX.Element",
+    "React.ReactNode",
+    "React.ReactElement"
+  ].includes(typeName);
+}
+function resolvePropKind(type) {
+  if (type.isString() || type.isStringLiteral()) return "string";
+  if (type.isNumber() || type.isNumberLiteral()) return "number";
+  if (type.isBoolean() || type.isBooleanLiteral()) return "boolean";
+  if (type.isNull()) return "null";
+  if (type.isUndefined()) return "undefined";
+  if (type.isNever()) return "never";
+  if (type.isAny()) return "any";
+  if (type.isUnknown()) return "unknown";
+  if (type.isArray()) return "array";
+  if (type.isTuple()) return "array";
+  const typeText = type.getText();
+  if (isReactNode(typeText)) return "node";
+  if (type.isUnion()) return "union";
+  if (typeText.includes("=>") || typeText.startsWith("(")) return "function";
+  if (type.isObject()) return "object";
+  return "other";
+}
+function expandUnionValues(type) {
+  if (!type.isUnion()) return void 0;
+  const values = [];
+  for (const member of type.getUnionTypes()) {
+    if (member.isStringLiteral()) {
+      values.push(member.getLiteralValue());
+    } else if (member.isNumberLiteral()) {
+      values.push(String(member.getLiteralValue()));
+    } else if (member.isBooleanLiteral()) {
+      values.push(String(member.getLiteralValue()));
+    }
+  }
+  return values.length > 0 ? values : void 0;
+}
+function buildPropDescriptor(type, required, defaultValue) {
+  const kind = resolvePropKind(type);
+  const desc = {
+    type: kind,
+    required,
+    rawType: type.getText().replace(/import\("[^"]*"\)\./g, "")
+  };
+  if (kind === "union") {
+    const expanded = expandUnionValues(type);
+    if (expanded) desc.values = expanded;
+  }
+  if (defaultValue !== void 0) {
+    desc.default = defaultValue;
+    desc.required = false;
+  }
+  return desc;
+}
+function extractPropsFromType(typeName, sourceFile, defaultValues = {}) {
+  const props = {};
+  const iface = sourceFile.getInterface(typeName);
+  if (iface) {
+    for (const prop of iface.getProperties()) {
+      const name = prop.getName();
+      if (name.startsWith("[")) continue;
+      const type = prop.getType();
+      const required = !prop.hasQuestionToken();
+      props[name] = buildPropDescriptor(type, required, defaultValues[name]);
+    }
+    return props;
+  }
+  const typeAlias = sourceFile.getTypeAlias(typeName);
+  if (typeAlias) {
+    const aliasType = typeAlias.getType();
+    if (aliasType.isObject()) {
+      for (const prop of aliasType.getProperties()) {
+        const name = prop.getName();
+        if (name.startsWith("[")) continue;
+        const decls = prop.getDeclarations();
+        const required = decls.length === 0 || !prop.getDeclarations().some((d) => tsMorph.Node.isPropertySignature(d) && d.hasQuestionToken());
+        const valType = prop.getTypeAtLocation(sourceFile);
+        props[name] = buildPropDescriptor(valType, required, defaultValues[name]);
+      }
+    }
+    return props;
+  }
+  return props;
+}
+function inferPropsTypeName(params) {
+  if (params.length === 0) return void 0;
+  const firstParam = params[0];
+  if (!firstParam) return void 0;
+  const typeNode = firstParam.getTypeNode?.();
+  if (!typeNode) return void 0;
+  return typeNode.getText().trim();
+}
+function extractDefaultsFromDestructuring(params) {
+  const defaults = {};
+  if (params.length === 0) return defaults;
+  const firstParam = params[0];
+  if (!firstParam) return defaults;
+  const nameNode = firstParam.getNameNode();
+  if (!tsMorph.Node.isObjectBindingPattern(nameNode)) return defaults;
+  for (const element of nameNode.getElements()) {
+    const initializer = element.getInitializer();
+    if (initializer) {
+      const propName = element.getPropertyNameNode()?.getText() ?? element.getName();
+      defaults[propName] = initializer.getText();
+    }
+  }
+  return defaults;
+}
+function collectJsxCompositions(node) {
+  const names = /* @__PURE__ */ new Set();
+  function visit(n) {
+    if (tsMorph.Node.isJsxOpeningElement(n) || tsMorph.Node.isJsxSelfClosingElement(n)) {
+      const tagNameNode = n.getTagNameNode();
+      const tagName = tagNameNode.getText();
+      if (/^[A-Z]/.test(tagName)) {
+        const base = tagName.split(".")[0] ?? tagName;
+        if (base && /^[A-Z]/.test(base) && !["React", "Fragment"].includes(base)) {
+          names.add(base);
+        }
+      }
+    }
+    n.forEachChild(visit);
+  }
+  visit(node);
+  return Array.from(names);
+}
+function detectWrappers(node) {
+  let memoized = false;
+  let forwardedRef = false;
+  const hocWrappers = [];
+  function visitCall(n) {
+    if (!tsMorph.Node.isCallExpression(n)) return;
+    const expr = n.getExpression();
+    const name = expr.getText();
+    if (name === "React.memo" || name === "memo") {
+      memoized = true;
+      const args = n.getArguments();
+      if (args[0]) visitCall(args[0]);
+    } else if (name === "React.forwardRef" || name === "forwardRef") {
+      forwardedRef = true;
+      const args = n.getArguments();
+      if (args[0]) visitCall(args[0]);
+    } else {
+      const args = n.getArguments();
+      if (args.length > 0) {
+        const firstArg = args[0];
+        if (firstArg && (tsMorph.Node.isIdentifier(firstArg) || tsMorph.Node.isCallExpression(firstArg))) {
+          const calleeName = name.split(".").pop() ?? name;
+          if (/^[a-z]/.test(calleeName)) {
+            hocWrappers.push(calleeName);
+          }
+          if (tsMorph.Node.isCallExpression(firstArg)) {
+            visitCall(firstArg);
+          }
+        }
+      }
+    }
+  }
+  visitCall(node);
+  return { memoized, forwardedRef, hocWrappers };
+}
+function extractNameFromWrappedCall(node) {
+  if (!tsMorph.Node.isCallExpression(node)) return void 0;
+  const args = node.getArguments();
+  if (args.length === 0) return void 0;
+  const firstArg = args[0];
+  if (!firstArg) return void 0;
+  if (tsMorph.Node.isFunctionExpression(firstArg)) {
+    return firstArg.getName() ?? void 0;
+  }
+  if (tsMorph.Node.isIdentifier(firstArg)) {
+    return firstArg.getText();
+  }
+  if (tsMorph.Node.isCallExpression(firstArg)) {
+    return extractNameFromWrappedCall(firstArg);
+  }
+  return void 0;
+}
+function nodeReturnsJsx(node) {
+  let found = false;
+  function visit(n) {
+    if (found) return;
+    if (tsMorph.Node.isJsxElement(n) || tsMorph.Node.isJsxFragment(n) || tsMorph.Node.isJsxSelfClosingElement(n)) {
+      found = true;
+      return;
+    }
+    n.forEachChild(visit);
+  }
+  visit(node);
+  return found;
+}
+function processSourceFile(sourceFile, rootDir, project) {
+  const results = [];
+  const filePath = path.relative(rootDir, sourceFile.getFilePath());
+  let defaultExportName;
+  const defaultExportWrappers = /* @__PURE__ */ new Map();
+  sourceFile.forEachChild((node) => {
+    if (tsMorph.Node.isExportAssignment(node)) {
+      const expr = node.getExpression();
+      if (tsMorph.Node.isIdentifier(expr)) {
+        defaultExportName = expr.getText();
+      } else if (tsMorph.Node.isCallExpression(expr)) {
+        const innerName = extractNameFromWrappedCall(expr);
+        if (innerName) {
+          defaultExportName = innerName;
+          defaultExportWrappers.set(innerName, detectWrappers(expr));
+        }
+      }
+    }
+  });
+  const namedExports = /* @__PURE__ */ new Set();
+  for (const exportDecl of sourceFile.getExportSymbols()) {
+    namedExports.add(exportDecl.getName());
+  }
+  for (const fn of sourceFile.getFunctions()) {
+    const name = fn.getName();
+    if (!name) continue;
+    if (!/^[A-Z]/.test(name)) continue;
+    if (!nodeReturnsJsx(fn)) continue;
+    const params = fn.getParameters();
+    const propsTypeName = inferPropsTypeName(params);
+    const defaults = extractDefaultsFromDestructuring(params);
+    const props = propsTypeName ? extractPropsFromType(propsTypeName, sourceFile, defaults) : {};
+    const composes = collectJsxCompositions(fn);
+    const start = fn.getStartLineNumber();
+    const end = fn.getEndLineNumber();
+    let exportType = "none";
+    if (fn.isDefaultExport() || defaultExportName === name) exportType = "default";
+    else if (fn.isExported() || namedExports.has(name)) exportType = "named";
+    const fnWrappers = defaultExportWrappers.get(name) ?? {
+      memoized: false,
+      forwardedRef: false,
+      hocWrappers: []
+    };
+    results.push({
+      name,
+      descriptor: {
+        filePath,
+        exportType,
+        displayName: name,
+        props,
+        composes,
+        composedBy: [],
+        forwardedRef: fnWrappers.forwardedRef,
+        hocWrappers: fnWrappers.hocWrappers,
+        memoized: fnWrappers.memoized,
+        loc: { start, end },
+        complexityClass: analyzeComplexity(fn),
+        detectedHooks: detectHooks(fn),
+        requiredContexts: detectRequiredContexts(fn, sourceFile, project),
+        sideEffects: detectSideEffects(fn)
+      }
+    });
+  }
+  for (const varStmt of sourceFile.getVariableStatements()) {
+    const isExported = varStmt.isExported();
+    for (const varDecl of varStmt.getDeclarations()) {
+      const varName = varDecl.getName();
+      if (!/^[A-Z]/.test(varName)) continue;
+      const initializer = varDecl.getInitializer();
+      if (!initializer) continue;
+      const wrappers = detectWrappers(initializer);
+      let innerName;
+      let bodyNode = initializer;
+      if (tsMorph.Node.isCallExpression(initializer)) {
+        innerName = extractNameFromWrappedCall(initializer);
+        const args = initializer.getArguments();
+        const firstArg = args[0];
+        if (firstArg) {
+          if (tsMorph.Node.isArrowFunction(firstArg) || tsMorph.Node.isFunctionExpression(firstArg)) {
+            bodyNode = firstArg;
+          } else if (tsMorph.Node.isCallExpression(firstArg)) {
+            const innerArgs = firstArg.getArguments();
+            const innerFirst = innerArgs[0];
+            if (innerFirst && (tsMorph.Node.isArrowFunction(innerFirst) || tsMorph.Node.isFunctionExpression(innerFirst))) {
+              bodyNode = innerFirst;
+            }
+          }
+        }
+      }
+      if (!nodeReturnsJsx(bodyNode)) continue;
+      const componentName = innerName ?? varName;
+      let params = [];
+      if (tsMorph.Node.isArrowFunction(bodyNode) || tsMorph.Node.isFunctionExpression(bodyNode)) {
+        params = bodyNode.getParameters();
+      }
+      const propsTypeName = inferPropsTypeName(params);
+      const defaults = extractDefaultsFromDestructuring(params);
+      const props = propsTypeName ? extractPropsFromType(propsTypeName, sourceFile, defaults) : {};
+      const composes = collectJsxCompositions(bodyNode);
+      const startLine = varDecl.getStartLineNumber();
+      const endLine = varDecl.getEndLineNumber();
+      let exportType = "none";
+      if (defaultExportName === varName || defaultExportName === componentName) {
+        exportType = "default";
+      } else if (isExported || namedExports.has(varName)) {
+        exportType = "named";
+      }
+      results.push({
+        name: componentName === varName ? componentName : varName,
+        descriptor: {
+          filePath,
+          exportType,
+          displayName: componentName,
+          props,
+          composes,
+          composedBy: [],
+          forwardedRef: wrappers.forwardedRef,
+          hocWrappers: wrappers.hocWrappers,
+          memoized: wrappers.memoized,
+          loc: { start: startLine, end: endLine },
+          complexityClass: analyzeComplexity(bodyNode),
+          detectedHooks: detectHooks(bodyNode),
+          requiredContexts: detectRequiredContexts(bodyNode, sourceFile, project),
+          sideEffects: detectSideEffects(bodyNode)
+        }
+      });
+    }
+  }
+  for (const cls of sourceFile.getClasses()) {
+    const name = cls.getName();
+    if (!name) continue;
+    if (!/^[A-Z]/.test(name)) continue;
+    const baseClass = cls.getBaseClass()?.getName();
+    if (!baseClass && !cls.getExtends()) continue;
+    const extendsText = cls.getExtends()?.getText() ?? "";
+    if (!extendsText.includes("Component") && !extendsText.includes("PureComponent")) {
+      continue;
+    }
+    const renderMethod = cls.getMethod("render");
+    if (!renderMethod || !nodeReturnsJsx(renderMethod)) continue;
+    const extendsNode = cls.getExtends();
+    let propsTypeName;
+    if (extendsNode) {
+      const typeArgs = extendsNode.getTypeArguments();
+      if (typeArgs[0]) {
+        propsTypeName = typeArgs[0].getText().trim();
+      }
+    }
+    const props = propsTypeName ? extractPropsFromType(propsTypeName, sourceFile) : {};
+    const composes = collectJsxCompositions(renderMethod);
+    const start = cls.getStartLineNumber();
+    const end = cls.getEndLineNumber();
+    let exportType = "none";
+    if (cls.isDefaultExport() || defaultExportName === name) exportType = "default";
+    else if (cls.isExported() || namedExports.has(name)) exportType = "named";
+    results.push({
+      name,
+      descriptor: {
+        filePath,
+        exportType,
+        displayName: name,
+        props,
+        composes,
+        composedBy: [],
+        forwardedRef: false,
+        hocWrappers: [],
+        memoized: false,
+        loc: { start, end },
+        complexityClass: "complex",
+        detectedHooks: [],
+        requiredContexts: [],
+        sideEffects: detectSideEffects(cls)
+      }
+    });
+  }
+  return results;
+}
+function generateManifest(config) {
+  const {
+    rootDir,
+    include = ["src/**/*.tsx", "src/**/*.ts"],
+    exclude = ["**/node_modules/**", "**/*.test.*", "**/*.spec.*", "**/dist/**", "**/*.d.ts"],
+    tsConfigFilePath = path.join(rootDir, "tsconfig.json")
+  } = config;
+  const project = new tsMorph.Project({
+    tsConfigFilePath,
+    skipAddingFilesFromTsConfig: true
+  });
+  const includePatterns = include.map((g) => path.join(rootDir, g));
+  project.addSourceFilesFromTsConfig(tsConfigFilePath);
+  for (const pattern of includePatterns) {
+    project.addSourceFilesAtPaths(pattern);
+  }
+  for (const sf of project.getSourceFiles()) {
+    const fp = sf.getFilePath();
+    const shouldExclude = exclude.some((ex) => {
+      const pattern = ex.replace(/\*\*/g, ".*").replace(/\*/g, "[^/]*").replace(/\./g, "\\.");
+      return new RegExp(pattern).test(fp);
+    });
+    if (shouldExclude) {
+      project.removeSourceFile(sf);
+    }
+  }
+  for (const sf of project.getSourceFiles()) {
+    if (!sf.getFilePath().startsWith(rootDir)) {
+      project.removeSourceFile(sf);
+    }
+  }
+  const allComponents = {};
+  for (const sf of project.getSourceFiles()) {
+    const rawComponents = processSourceFile(sf, rootDir, project);
+    for (const { name, descriptor } of rawComponents) {
+      if (allComponents[name] && descriptor.exportType === "none") continue;
+      allComponents[name] = descriptor;
+    }
+  }
+  for (const [name, desc] of Object.entries(allComponents)) {
+    for (const child of desc.composes) {
+      if (allComponents[child]) {
+        const childDesc = allComponents[child];
+        if (childDesc && !childDesc.composedBy.includes(name)) {
+          childDesc.composedBy.push(name);
+        }
+      }
+    }
+  }
+  propagateComplexity(allComponents);
+  const tree = {};
+  for (const [name, desc] of Object.entries(allComponents)) {
+    const children = desc.composes.filter((c) => c in allComponents);
+    const parents = desc.composedBy.filter((p) => p in allComponents);
+    tree[name] = { children, parents };
+  }
+  return {
+    version: "0.1",
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    components: allComponents,
+    tree
+  };
+}
+
+exports.generateManifest = generateManifest;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map