@agent-scope/manifest 1.19.0 → 1.20.1

package/dist/index.cjs

@@ -335,7 +335,7 @@ function expandUnionValues(type) {
   }
   return values.length > 0 ? values : void 0;
 }
-function buildPropDescriptor(type, required, defaultValue) {
+function buildPropDescriptor(type, required, defaultValue, source, sourceGroup) {
   const kind = resolvePropKind(type);
   const desc = {
     type: kind,
@@ -350,6 +350,12 @@ function buildPropDescriptor(type, required, defaultValue) {
     desc.default = defaultValue;
     desc.required = false;
   }
+  if (source !== void 0) {
+    desc.source = source;
+  }
+  if (sourceGroup !== void 0) {
+    desc.sourceGroup = sourceGroup;
+  }
   return desc;
 }
 function extractPropsFromType(typeName, sourceFile, defaultValues = {}) {
@@ -361,25 +367,47 @@ function extractPropsFromType(typeName, sourceFile, defaultValues = {}) {
       if (name.startsWith("[")) continue;
       const type = prop.getType();
       const required = !prop.hasQuestionToken();
-      props[name] = buildPropDescriptor(type, required, defaultValues[name]);
+      props[name] = buildPropDescriptor(type, required, defaultValues[name], "own");
     }
     return props;
   }
   const typeAlias = sourceFile.getTypeAlias(typeName);
   if (typeAlias) {
     const aliasType = typeAlias.getType();
-    if (aliasType.isObject()) {
+    if (aliasType.isObject() || aliasType.isIntersection()) {
       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());
+        let 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]);
+        if (required && typeIncludesUndefined(valType)) {
+          required = false;
+        }
+        const { source, sourceGroup } = classifyPropSource(prop);
+        props[name] = buildPropDescriptor(
+          valType,
+          required,
+          defaultValues[name],
+          source,
+          sourceGroup
+        );
       }
     }
     return props;
   }
+  for (const importDecl of sourceFile.getImportDeclarations()) {
+    const match = importDecl.getNamedImports().find((ni) => {
+      const localName = ni.getAliasNode()?.getText() ?? ni.getName();
+      return localName === typeName;
+    });
+    if (!match) continue;
+    const importedFile = importDecl.getModuleSpecifierSourceFile();
+    if (importedFile) {
+      const originalName = match.getName();
+      return extractPropsFromType(originalName, importedFile, defaultValues);
+    }
+  }
   return props;
 }
 function inferPropsTypeName(params) {
@@ -476,6 +504,78 @@ function extractNameFromWrappedCall(node) {
   }
   return void 0;
 }
+function extractForwardRefPropsTypeNode(node) {
+  if (!tsMorph.Node.isCallExpression(node)) return void 0;
+  const expr = node.getExpression();
+  const name = expr.getText();
+  if (name === "React.forwardRef" || name === "forwardRef") {
+    const typeArgs = node.getTypeArguments();
+    if (typeArgs.length >= 2 && typeArgs[1]) {
+      return typeArgs[1];
+    }
+    return void 0;
+  }
+  const args = node.getArguments();
+  if (args[0] && tsMorph.Node.isCallExpression(args[0])) {
+    return extractForwardRefPropsTypeNode(args[0]);
+  }
+  return void 0;
+}
+function typeIncludesUndefined(type) {
+  if (type.isUndefined()) return true;
+  if (type.isUnion()) {
+    return type.getUnionTypes().some((t) => t.isUndefined());
+  }
+  return false;
+}
+var REACT_INTERFACES = /* @__PURE__ */ new Set([
+  "Attributes",
+  "RefAttributes",
+  "ClassAttributes",
+  "DOMAttributes"
+]);
+function classifyPropSource(prop) {
+  const decls = prop.getDeclarations();
+  if (decls.length === 0) return { source: "inherited" };
+  const allInNodeModules = decls.every(
+    (d) => d.getSourceFile().getFilePath().includes("/node_modules/")
+  );
+  if (!allInNodeModules) return { source: "own" };
+  for (const d of decls) {
+    const parent = d.getParent();
+    if (!tsMorph.Node.isInterfaceDeclaration(parent)) continue;
+    const ifaceName = parent.getName();
+    if (ifaceName === "AriaAttributes") return { source: "inherited", sourceGroup: "aria" };
+    if (ifaceName.endsWith("HTMLAttributes")) return { source: "inherited", sourceGroup: "html" };
+    if (REACT_INTERFACES.has(ifaceName)) return { source: "inherited", sourceGroup: "react" };
+  }
+  const filePath = decls[0]?.getSourceFile().getFilePath() ?? "";
+  const pkgMatch = filePath.match(/node_modules\/((?:@[^/]+\/)?[^/]+)/);
+  if (pkgMatch?.[1]) {
+    const pkg = pkgMatch[1];
+    if (pkg === "@types/react" || pkg === "react")
+      return { source: "inherited", sourceGroup: "react" };
+    return { source: "inherited", sourceGroup: pkg };
+  }
+  return { source: "inherited" };
+}
+function extractPropsFromResolvedType(resolvedType, sourceFile, defaultValues = {}) {
+  const props = {};
+  if (!resolvedType.isObject() && !resolvedType.isIntersection()) return props;
+  for (const prop of resolvedType.getProperties()) {
+    const name = prop.getName();
+    if (name.startsWith("[")) continue;
+    const decls = prop.getDeclarations();
+    let required = decls.length === 0 || !decls.some((d) => tsMorph.Node.isPropertySignature(d) && d.hasQuestionToken());
+    const valType = prop.getTypeAtLocation(sourceFile);
+    if (required && typeIncludesUndefined(valType)) {
+      required = false;
+    }
+    const { source, sourceGroup } = classifyPropSource(prop);
+    props[name] = buildPropDescriptor(valType, required, defaultValues[name], source, sourceGroup);
+  }
+  return props;
+}
 function nodeReturnsJsx(node) {
   let found = false;
   function visit(n) {
@@ -489,6 +589,62 @@ function nodeReturnsJsx(node) {
   visit(node);
   return found;
 }
+function matchGlob(pattern, value) {
+  const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&");
+  const regexStr = escaped.replace(/\*\*/g, "\xA7GLOBSTAR\xA7").replace(/\*/g, "[^/]*").replace(/§GLOBSTAR§/g, ".*");
+  const regex = new RegExp(`^${regexStr}$`, "i");
+  return regex.test(value);
+}
+function extractTsDocTags(declNode) {
+  let collection;
+  let internal = false;
+  const keywords = [];
+  const nodeWithDocs = declNode;
+  if (typeof nodeWithDocs.getJsDocs !== "function") {
+    return { collection, internal, keywords };
+  }
+  const jsDocs = nodeWithDocs.getJsDocs();
+  for (const jsDoc of jsDocs) {
+    for (const tag of jsDoc.getTags()) {
+      const tagName = tag.getTagName();
+      if (tagName === "collection") {
+        const comment = tag.getComment();
+        if (comment && typeof comment === "string") {
+          collection = comment.trim();
+        }
+      } else if (tagName === "internal") {
+        internal = true;
+      } else if (tagName === "keywords") {
+        const comment = tag.getComment();
+        if (comment && typeof comment === "string") {
+          for (const kw of comment.split(",")) {
+            const trimmed = kw.trim();
+            if (trimmed) keywords.push(trimmed);
+          }
+        }
+      }
+    }
+  }
+  return { collection, internal, keywords };
+}
+function readCollectionFromScopeFile(scopeFilePath, project) {
+  let sf = project.getSourceFile(scopeFilePath);
+  if (!sf) {
+    sf = project.addSourceFileAtPath(scopeFilePath);
+  }
+  for (const varStmt of sf.getVariableStatements()) {
+    if (!varStmt.isExported()) continue;
+    for (const varDecl of varStmt.getDeclarations()) {
+      if (varDecl.getName() !== "collection") continue;
+      const initializer = varDecl.getInitializer();
+      if (!initializer) continue;
+      if (tsMorph.Node.isStringLiteral(initializer)) {
+        return initializer.getLiteralValue();
+      }
+    }
+  }
+  return void 0;
+}
 function processSourceFile(sourceFile, rootDir, project) {
   const results = [];
   const filePath = path.relative(rootDir, sourceFile.getFilePath());
@@ -549,7 +705,10 @@ function processSourceFile(sourceFile, rootDir, project) {
         detectedHooks: detectHooks(fn),
         requiredContexts: detectRequiredContexts(fn, sourceFile, project),
         sideEffects: detectSideEffects(fn),
-        scopeFile: null
+        scopeFile: null,
+        // collection, internal, and keywords will be filled in after all components are collected
+        internal: false,
+        keywords: []
       }
     });
   }
@@ -587,7 +746,16 @@ function processSourceFile(sourceFile, rootDir, project) {
       }
       const propsTypeName = inferPropsTypeName(params);
       const defaults = extractDefaultsFromDestructuring(params);
-      const props = propsTypeName ? extractPropsFromType(propsTypeName, sourceFile, defaults) : {};
+      let props = {};
+      if (propsTypeName) {
+        props = extractPropsFromType(propsTypeName, sourceFile, defaults);
+      }
+      if (Object.keys(props).length === 0 && wrappers.forwardedRef) {
+        const propsTypeNode = extractForwardRefPropsTypeNode(initializer);
+        if (propsTypeNode) {
+          props = extractPropsFromResolvedType(propsTypeNode.getType(), sourceFile, defaults);
+        }
+      }
       const composes = collectJsxCompositions(bodyNode);
       const startLine = varDecl.getStartLineNumber();
       const endLine = varDecl.getEndLineNumber();
@@ -614,7 +782,9 @@ function processSourceFile(sourceFile, rootDir, project) {
           detectedHooks: detectHooks(bodyNode),
           requiredContexts: detectRequiredContexts(bodyNode, sourceFile, project),
           sideEffects: detectSideEffects(bodyNode),
-          scopeFile: null
+          scopeFile: null,
+          internal: false,
+          keywords: []
         }
       });
     }
@@ -663,19 +833,22 @@ function processSourceFile(sourceFile, rootDir, project) {
         detectedHooks: [],
         requiredContexts: [],
         sideEffects: detectSideEffects(cls),
-        scopeFile: null
+        scopeFile: null,
+        internal: false,
+        keywords: []
       }
     });
   }
   return results;
 }
 function generateManifest(config) {
+  const normalizedRootDir = fs.realpathSync(config.rootDir);
   const {
-    rootDir,
     include = ["src/**/*.tsx", "src/**/*.ts"],
     exclude = ["**/node_modules/**", "**/*.test.*", "**/*.spec.*", "**/dist/**", "**/*.d.ts"],
-    tsConfigFilePath = path.join(rootDir, "tsconfig.json")
+    tsConfigFilePath = path.join(normalizedRootDir, "tsconfig.json")
   } = config;
+  const rootDir = normalizedRootDir;
   const project = new tsMorph.Project({
     tsConfigFilePath,
     skipAddingFilesFromTsConfig: true
@@ -731,11 +904,78 @@ function generateManifest(config) {
       desc.scopeFile = scopeMeta;
     }
   }
+  const configCollections = config.collections ?? [];
+  const internalPatterns = config.internalPatterns ?? [];
+  for (const [compName, desc] of Object.entries(allComponents)) {
+    const absFilePath = desc.filePath.startsWith("/") ? desc.filePath : path.join(rootDir, desc.filePath);
+    const sf = project.getSourceFile(absFilePath);
+    let tsdocCollection;
+    let tsdocInternal = false;
+    let tsdocKeywords = [];
+    if (sf) {
+      const fn = sf.getFunction(compName);
+      if (fn) {
+        const tags = extractTsDocTags(fn);
+        tsdocCollection = tags.collection;
+        tsdocInternal = tags.internal;
+        tsdocKeywords = tags.keywords;
+      }
+      if (tsdocCollection === void 0 && !tsdocInternal && tsdocKeywords.length === 0) {
+        const varDecl = sf.getVariableDeclaration(compName);
+        if (varDecl) {
+          const varStmt = varDecl.getVariableStatement();
+          if (varStmt) {
+            const tags = extractTsDocTags(varStmt);
+            tsdocCollection = tags.collection;
+            tsdocInternal = tags.internal;
+            tsdocKeywords = tags.keywords;
+          }
+        }
+      }
+      if (tsdocCollection === void 0 && !tsdocInternal && tsdocKeywords.length === 0) {
+        const cls = sf.getClass(compName);
+        if (cls) {
+          const tags = extractTsDocTags(cls);
+          tsdocCollection = tags.collection;
+          tsdocInternal = tags.internal;
+          tsdocKeywords = tags.keywords;
+        }
+      }
+    }
+    let scopeFileCollection;
+    if (desc.scopeFile) {
+      scopeFileCollection = readCollectionFromScopeFile(desc.scopeFile.filePath, project);
+    }
+    let configCollection;
+    for (const colConfig of configCollections) {
+      if (colConfig.patterns.some((p) => matchGlob(p, desc.filePath))) {
+        configCollection = colConfig.name;
+        break;
+      }
+    }
+    let configInternal = false;
+    if (internalPatterns.length > 0) {
+      configInternal = internalPatterns.some(
+        (p) => matchGlob(p, desc.filePath) || matchGlob(p, desc.displayName)
+      );
+    }
+    const iconPats = config.iconPatterns ?? [];
+    const isIcon = iconPats.length > 0 && iconPats.some((p) => matchGlob(p, desc.filePath) || matchGlob(p, desc.displayName));
+    const resolvedCollection = tsdocCollection ?? scopeFileCollection ?? configCollection;
+    if (resolvedCollection !== void 0) {
+      desc.collection = resolvedCollection;
+    }
+    desc.internal = tsdocInternal || configInternal || isIcon;
+    if (tsdocKeywords.length > 0) {
+      desc.keywords = tsdocKeywords;
+    }
+  }
   return {
     version: "0.1",
     generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
     components: allComponents,
-    tree
+    tree,
+    collections: configCollections
   };
 }
 var SCOPE_EXTENSIONS = [".scope.tsx", ".scope.ts", ".scope.jsx", ".scope.js"];
@@ -745,7 +985,103 @@ function detectScopeFile(componentFilePath, rootDir) {
   for (const ext of SCOPE_EXTENSIONS) {
     const candidate = `${stem}${ext}`;
     if (fs.existsSync(candidate)) {
-      return { filePath: candidate, scenarioNames: [], hasWrapper: false };
+      return readScopeFileMeta(candidate);
+    }
+  }
+  return null;
+}
+function readScopeFileMeta(filePath) {
+  const source = fs.readFileSync(filePath, "utf-8");
+  const scenarioNames = extractScenarioNames(source);
+  const hasWrapper = /\bexport\s+(?:const|function)\s+wrapper\b/.test(source) || /\bwrapper\s*:/.test(source);
+  return { filePath, scenarioNames, hasWrapper };
+}
+function extractScenarioNames(source) {
+  const objectSource = extractScenarioObjectLiteral(source, /\bexport\s+const\s+scenarios\s*=\s*\{/) ?? extractScenarioObjectLiteral(source, /\bscenarios\s*:\s*\{/);
+  if (objectSource === null) return [];
+  const names = /* @__PURE__ */ new Set();
+  let depth = 0;
+  let quote = null;
+  let escaped = false;
+  let token = "";
+  const flushTokenAsKey = () => {
+    const name = token.trim().replace(/^['"]|['"]$/g, "");
+    if (depth === 0 && name && name !== "scenarios" && name !== "wrapper") {
+      names.add(name);
+    }
+    token = "";
+  };
+  for (let i = 0; i < objectSource.length; i += 1) {
+    const char = objectSource[i];
+    if (quote !== null) {
+      token += char;
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      token += char;
+      continue;
+    }
+    if (char === "{") {
+      depth += 1;
+      token = "";
+      continue;
+    }
+    if (char === "}") {
+      depth = Math.max(0, depth - 1);
+      token = "";
+      continue;
+    }
+    if (depth === 0 && char === ":") {
+      flushTokenAsKey();
+      continue;
+    }
+    if (depth === 0 && char === ",") {
+      token = "";
+      continue;
+    }
+    token += char;
+  }
+  return [...names];
+}
+function extractScenarioObjectLiteral(source, pattern) {
+  const match = pattern.exec(source);
+  if (!match) return null;
+  const openBraceIndex = source.indexOf("{", match.index);
+  if (openBraceIndex < 0) return null;
+  let depth = 0;
+  let quote = null;
+  let escaped = false;
+  for (let i = openBraceIndex; i < source.length; i += 1) {
+    const char = source[i];
+    if (quote !== null) {
+      if (escaped) {
+        escaped = false;
+      } else if (char === "\\") {
+        escaped = true;
+      } else if (char === quote) {
+        quote = null;
+      }
+      continue;
+    }
+    if (char === '"' || char === "'" || char === "`") {
+      quote = char;
+      continue;
+    }
+    if (char === "{") {
+      depth += 1;
+      continue;
+    }
+    if (char === "}") {
+      depth -= 1;
+      if (depth === 0) return source.slice(openBraceIndex + 1, i);
     }
   }
   return null;