@agent-scope/manifest 1.20.0 → 1.20.2

package/dist/index.js

@@ -1,4 +1,4 @@
-import { existsSync } from 'fs';
+import { realpathSync, existsSync, readFileSync } from 'fs';
 import { join, relative } from 'path';
 import { Project, Node } from 'ts-morph';
 
@@ -333,7 +333,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,
@@ -348,6 +348,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 = {}) {
@@ -359,25 +365,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) => Node.isPropertySignature(d) && d.hasQuestionToken());
+        let required = decls.length === 0 || !prop.getDeclarations().some((d) => 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) {
@@ -474,6 +502,78 @@ function extractNameFromWrappedCall(node) {
   }
   return void 0;
 }
+function extractForwardRefPropsTypeNode(node) {
+  if (!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] && 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 (!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) => 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) {
@@ -496,9 +596,10 @@ function matchGlob(pattern, value) {
 function extractTsDocTags(declNode) {
   let collection;
   let internal = false;
+  const keywords = [];
   const nodeWithDocs = declNode;
   if (typeof nodeWithDocs.getJsDocs !== "function") {
-    return { collection, internal };
+    return { collection, internal, keywords };
   }
   const jsDocs = nodeWithDocs.getJsDocs();
   for (const jsDoc of jsDocs) {
@@ -511,10 +612,18 @@ function extractTsDocTags(declNode) {
         }
       } 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 };
+  return { collection, internal, keywords };
 }
 function readCollectionFromScopeFile(scopeFilePath, project) {
   let sf = project.getSourceFile(scopeFilePath);
@@ -595,8 +704,9 @@ function processSourceFile(sourceFile, rootDir, project) {
         requiredContexts: detectRequiredContexts(fn, sourceFile, project),
         sideEffects: detectSideEffects(fn),
         scopeFile: null,
-        // collection and internal will be filled in after all components are collected
-        internal: false
+        // collection, internal, and keywords will be filled in after all components are collected
+        internal: false,
+        keywords: []
       }
     });
   }
@@ -634,7 +744,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();
@@ -662,7 +781,8 @@ function processSourceFile(sourceFile, rootDir, project) {
           requiredContexts: detectRequiredContexts(bodyNode, sourceFile, project),
           sideEffects: detectSideEffects(bodyNode),
           scopeFile: null,
-          internal: false
+          internal: false,
+          keywords: []
         }
       });
     }
@@ -712,19 +832,21 @@ function processSourceFile(sourceFile, rootDir, project) {
         requiredContexts: [],
         sideEffects: detectSideEffects(cls),
         scopeFile: null,
-        internal: false
+        internal: false,
+        keywords: []
       }
     });
   }
   return results;
 }
 function generateManifest(config) {
+  const normalizedRootDir = realpathSync(config.rootDir);
   const {
-    rootDir,
     include = ["src/**/*.tsx", "src/**/*.ts"],
     exclude = ["**/node_modules/**", "**/*.test.*", "**/*.spec.*", "**/dist/**", "**/*.d.ts"],
-    tsConfigFilePath = join(rootDir, "tsconfig.json")
+    tsConfigFilePath = join(normalizedRootDir, "tsconfig.json")
   } = config;
+  const rootDir = normalizedRootDir;
   const project = new Project({
     tsConfigFilePath,
     skipAddingFilesFromTsConfig: true
@@ -787,14 +909,16 @@ function generateManifest(config) {
     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) {
+      if (tsdocCollection === void 0 && !tsdocInternal && tsdocKeywords.length === 0) {
         const varDecl = sf.getVariableDeclaration(compName);
         if (varDecl) {
           const varStmt = varDecl.getVariableStatement();
@@ -802,15 +926,17 @@ function generateManifest(config) {
             const tags = extractTsDocTags(varStmt);
             tsdocCollection = tags.collection;
             tsdocInternal = tags.internal;
+            tsdocKeywords = tags.keywords;
           }
         }
       }
-      if (tsdocCollection === void 0 && !tsdocInternal) {
+      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;
         }
       }
     }
@@ -831,11 +957,16 @@ function generateManifest(config) {
         (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;
+    desc.internal = tsdocInternal || configInternal || isIcon;
+    if (tsdocKeywords.length > 0) {
+      desc.keywords = tsdocKeywords;
+    }
   }
   return {
     version: "0.1",
@@ -852,7 +983,103 @@ function detectScopeFile(componentFilePath, rootDir) {
   for (const ext of SCOPE_EXTENSIONS) {
     const candidate = `${stem}${ext}`;
     if (existsSync(candidate)) {
-      return { filePath: candidate, scenarioNames: [], hasWrapper: false };
+      return readScopeFileMeta(candidate);
+    }
+  }
+  return null;
+}
+function readScopeFileMeta(filePath) {
+  const source = 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;