@justmpm/ai-tool 3.20.1 → 3.21.0

package/dist/{chunk-IC74XLRN.js → chunk-KOMBNMGC.js}

@@ -20,7 +20,7 @@ import {
   readConfig,
   recoveryHint,
   simplifyType
-} from "./chunk-XDFC3IL7.js";
+} from "./chunk-RGRCXEIT.js";
 
 // src/commands/describe.ts
 var STOPWORDS = /* @__PURE__ */ new Set([
@@ -930,21 +930,30 @@ function collectRemainingIndexFiles(packagePath, existingFiles, results, maxFile
 import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
 import { dirname, join as join2, resolve as resolve2 } from "path";
 import { Project } from "ts-morph";
-function classifyFunctionKind(name, returnType) {
+
+// src/ts/kind-resolvers.ts
+var REACT_COMPONENT_FACTORIES = /* @__PURE__ */ new Set([
+  // React API principal
+  "memo",
+  "forwardRef",
+  "lazy",
+  "createContext",
+  "createElement",
+  "cloneElement",
+  "createFactory",
+  // Hooks que retornam componentes
+  "useCallback",
+  "useMemo",
+  // Suspense e ErrorBoundary
+  "Suspense",
+  "ErrorBoundary",
+  // Factory patterns
+  "createComponent",
+  "forwardRefLazy"
+]);
+function isReactComponentFactory(name) {
   const cleanName = stripModulePrefix(name);
-  if (cleanName.startsWith("use") && cleanName.length > 3 && cleanName[3] === cleanName[3].toUpperCase()) {
-    return "hook";
-  }
-  if (/^[A-Z]/.test(cleanName)) {
-    if (returnType) {
-      const rt = returnType.toLowerCase();
-      if (rt.includes("jsx.element") || rt.includes("reactelement") || rt.includes("reactnode") || rt.includes("react.fc") || rt.includes("elementtype")) {
-        return "component";
-      }
-    }
-    return "function";
-  }
-  return "function";
+  return REACT_COMPONENT_FACTORIES.has(cleanName);
 }
 function stripModulePrefix(name) {
   const dotIdx = name.indexOf(".");
@@ -958,6 +967,144 @@ function stripModulePrefix(name) {
   }
   return name;
 }
+var defaultResolver = {
+  canHandle: () => true,
+  // Fallback - sempre se aplica
+  classifyFunction(name, returnType) {
+    const cleanName = stripModulePrefix(name);
+    if (cleanName.startsWith("use") && cleanName.length > 3 && cleanName[3] === cleanName[3].toUpperCase()) {
+      return "hook";
+    }
+    if (isReactComponentFactory(name)) {
+      return "component";
+    }
+    if (/^[A-Z]/.test(cleanName)) {
+      if (returnType) {
+        const rt = returnType.toLowerCase();
+        if (rt.includes("jsx.element") || rt.includes("reactelement") || rt.includes("reactnode") || rt.includes("react.fc") || rt.includes("elementtype") || rt.includes("react.componenttype") || rt.includes("fc<") || rt.includes(".element")) {
+          return "component";
+        }
+      }
+      return "function";
+    }
+    return "function";
+  },
+  classifyType(_name, kind) {
+    return kind;
+  }
+};
+var reactResolver = {
+  canHandle(packageName) {
+    return packageName === "react" || packageName === "@types/react" || packageName === "react-dom" || packageName === "@types/react-dom";
+  },
+  classifyFunction(name, returnType) {
+    const cleanName = stripModulePrefix(name);
+    const reactHooks = /* @__PURE__ */ new Set([
+      // Hooks basicos
+      "useState",
+      "useEffect",
+      "useContext",
+      "useReducer",
+      "useCallback",
+      "useMemo",
+      "useRef",
+      "useImperativeHandle",
+      "useLayoutEffect",
+      "useDebugValue",
+      "useId",
+      // Hooks adicionais
+      "useTransition",
+      "useDeferredValue",
+      "useSyncExternalStore",
+      "useInsertionEffect",
+      "useFormStatus",
+      "useActionState",
+      "useOptimistic",
+      "use"
+    ]);
+    if (reactHooks.has(cleanName)) {
+      return "hook";
+    }
+    if (isReactComponentFactory(name)) {
+      return "component";
+    }
+    if (cleanName.startsWith("use") && cleanName.length > 3 && cleanName[3] === cleanName[3].toUpperCase()) {
+      return "hook";
+    }
+    if (/^[A-Z]/.test(cleanName)) {
+      if (returnType) {
+        const rt = returnType.toLowerCase();
+        if (rt.includes("jsx.element") || rt.includes("reactelement") || rt.includes("reactnode") || rt.includes("react.fc") || rt.includes("elementtype") || rt.includes("react.componenttype") || rt.includes("fc<") || rt.includes(".element")) {
+          return "component";
+        }
+      }
+      return "function";
+    }
+    return "function";
+  },
+  classifyType(name, kind) {
+    const cleanName = stripModulePrefix(name);
+    const reactComponentInterfaces = /* @__PURE__ */ new Set([
+      "FC",
+      "FunctionComponent",
+      "ComponentType",
+      "ElementType",
+      "Element",
+      "ReactElement",
+      "ReactNode",
+      "Component",
+      "PureComponent",
+      "ForwardRefExoticComponent",
+      "ExoticComponent"
+    ]);
+    if (reactComponentInterfaces.has(cleanName)) {
+      return "component";
+    }
+    return kind;
+  }
+};
+var resolvers = [
+  reactResolver,
+  defaultResolver
+  // Fallback - deve ser o ultimo
+];
+function getResolver(packageName) {
+  for (const resolver of resolvers) {
+    if (resolver.canHandle(packageName)) {
+      return resolver;
+    }
+  }
+  return defaultResolver;
+}
+function classifyFunctionKind(name, returnType, packageName) {
+  const resolver = packageName ? getResolver(packageName) : defaultResolver;
+  return resolver.classifyFunction(name, returnType);
+}
+function classifyTypeKind(name, kind, packageName) {
+  const resolver = packageName ? getResolver(packageName) : defaultResolver;
+  return resolver.classifyType(name, kind);
+}
+function classifySymbol(symbolKind, name, returnType, packageName) {
+  if (symbolKind === "function") {
+    return classifyFunctionKind(name, returnType, packageName);
+  }
+  if (symbolKind === "type" || symbolKind === "interface" || symbolKind === "enum") {
+    return classifyTypeKind(name, symbolKind, packageName);
+  }
+  return "const";
+}
+function isSemanticKindMatch(actualKind, requestedKind) {
+  if (actualKind === requestedKind) return true;
+  if (requestedKind === "type") {
+    return actualKind === "interface" || actualKind === "enum" || actualKind === "const";
+  }
+  if (requestedKind === "function") {
+    return actualKind === "component" || actualKind === "hook";
+  }
+  return false;
+}
+
+// src/ts/package-extractor.ts
 var MAX_REEXPORT_DEPTH = 3;
 var MAX_TOTAL_FILES = 1200;
 var TYPE_DECLARATION_EXTENSIONS = [".d.ts", ".d.cts", ".d.mts", ".d.tsx"];
@@ -1284,7 +1431,7 @@ function extractPackageApiImpl(project, typeFiles, packagePath, limit, jsFallbac
         allFunctions.push({
           ...fn,
           sourceFile: relativeSource,
-          kind: classifyFunctionKind(fn.name, fn.returnType)
+          kind: classifySymbol("function", fn.name, fn.returnType)
         });
       }
     }
@@ -1387,36 +1534,30 @@ function sortByRelevance(items, publicApiNames) {
 }
 
 // src/commands/deps.ts
-function stripModulePrefix2(name) {
-  const dotIdx = name.indexOf(".");
-  if (dotIdx === -1) return name;
-  const prefix = name.slice(0, dotIdx);
-  if (prefix.startsWith('"') || prefix.startsWith("'")) {
-    return name.slice(dotIdx + 1);
+function normalizePath(p) {
+  return p.replace(/\\/g, "/");
+}
+function computeAvailableKinds(extracted, requestedKind) {
+  const kindCounts = /* @__PURE__ */ new Map();
+  for (const fn of extracted.functions) {
+    const kind = classifySymbol("function", fn.name, fn.returnType);
+    if (isSemanticKindMatch(kind, requestedKind)) {
+      kindCounts.set(kind, (kindCounts.get(kind) ?? 0) + 1);
+    }
   }
-  if (/^[A-Za-z]+$/.test(prefix) && /^[A-Z]/.test(prefix)) {
-    return name.slice(dotIdx + 1);
+  for (const t of extracted.types) {
+    const kind = classifySymbol("type", t.name);
+    if (isSemanticKindMatch(kind, requestedKind)) {
+      kindCounts.set(kind, (kindCounts.get(kind) ?? 0) + 1);
+    }
   }
-  return name;
-}
-function classifyFunctionKind2(name, returnType) {
-  const cleanName = stripModulePrefix2(name);
-  if (cleanName.startsWith("use") && cleanName.length > 3 && cleanName[3] === cleanName[3].toUpperCase()) {
-    return "hook";
-  }
-  if (/^[A-Z]/.test(cleanName)) {
-    if (returnType) {
-      const rt = returnType.toLowerCase();
-      if (rt.includes("jsx.element") || rt.includes("reactelement") || rt.includes("reactnode") || rt.includes("react.fc") || rt.includes("elementtype")) {
-        return "component";
-      }
+  for (const c of extracted.constants) {
+    const kind = classifySymbol("const", c.name);
+    if (isSemanticKindMatch(kind, requestedKind)) {
+      kindCounts.set(kind, (kindCounts.get(kind) ?? 0) + 1);
     }
-    return "function";
   }
-  return "function";
-}
-function normalizePath(p) {
-  return p.replace(/\\/g, "/");
+  return Array.from(kindCounts.entries()).map(([kind, count]) => ({ kind, count })).sort((a, b) => b.count - a.count);
 }
 function relativeTypeFile(typeFiles, normalizedPkgPath, packageName, sourceFile) {
   if (sourceFile) {
@@ -1427,16 +1568,6 @@ function relativeTypeFile(typeFiles, normalizedPkgPath, packageName, sourceFile)
   }
   return normalizePath(typeFiles[0]).replace(normalizedPkgPath, packageName);
 }
-function isKindMatch(actualKind, requestedKind) {
-  if (actualKind === requestedKind) return true;
-  if (requestedKind === "type") {
-    return actualKind === "interface" || actualKind === "enum" || actualKind === "const";
-  }
-  if (requestedKind === "function") {
-    return actualKind === "component" || actualKind === "hook";
-  }
-  return false;
-}
 var TYPE_FILES_COMPACT_THRESHOLD = 10;
 var TYPE_FILES_PREVIEW_COUNT = 5;
 function buildTypeFilesMeta(typeFiles, pkgPath) {
@@ -1543,9 +1674,9 @@ async function depsApi(packageName, options = {}) {
     let filteredConstants = extracted.constants;
     if (options.kind) {
       const kind = options.kind;
-      filteredFunctions = extracted.functions.filter((fn) => classifyFunctionKind2(fn.name, fn.returnType) === kind);
+      filteredFunctions = extracted.functions.filter((fn) => classifySymbol("function", fn.name, fn.returnType) === kind);
       filteredTypes = extracted.types.filter((t) => {
-        const resolvedKind = classifyFunctionKind2(t.name) === "hook" ? "hook" : t.kind;
+        const resolvedKind = classifySymbol("type", t.name) === "hook" ? "hook" : t.kind;
         return resolvedKind === kind;
       });
       filteredConstants = extracted.constants.filter(() => kind === "const");
@@ -1554,6 +1685,7 @@ async function depsApi(packageName, options = {}) {
       filteredTypes = filteredTypes.slice(0, realLimit);
       filteredConstants = filteredConstants.slice(0, realLimit);
     }
+    const availableKindsWhenFilteredEmpty = options.kind && filteredFunctions.length === 0 && filteredTypes.length === 0 ? computeAvailableKinds(extracted, options.kind) : void 0;
     const jsFallback = typeFiles.length > 0 && typeFiles.every(
       (f) => f.endsWith(".js") || f.endsWith(".mjs") || f.endsWith(".cjs")
     );
@@ -1575,6 +1707,7 @@ async function depsApi(packageName, options = {}) {
         totalTypes: filteredTypes.length,
         shown: Math.min(filteredFunctions.length, options.limit ?? 50)
       } : extracted.truncated,
+      availableKindsWhenFilteredEmpty,
       typeFilesSummary: typeFilesMeta.summary,
       typeFilesPreview: typeFilesMeta.preview,
       jsFallback: jsFallback || void 0,
@@ -1739,20 +1872,20 @@ async function depsSearch(packageName, query, options = {}) {
     const filesSet = /* @__PURE__ */ new Set();
     const normalizedPkgPath = normalizePath(pkgPath);
     const useWildcard = hasWildcard(query);
-    const matchFn = useWildcard ? (name) => matchWithWildcard(name, query) || matchWithWildcard(stripModulePrefix2(name), query) : (name) => {
+    const matchFn = useWildcard ? (name) => matchWithWildcard(name, query) || matchWithWildcard(stripModulePrefix(name), query) : (name) => {
       const n = name.toLowerCase();
-      const s = stripModulePrefix2(name).toLowerCase();
+      const s = stripModulePrefix(name).toLowerCase();
       return n === queryLower || s === queryLower;
     };
     const scoreFn = useWildcard ? (name, kind, isExported) => calculateWildcardMatchScore(name, query, kind, isExported) : (name, kind, isExported) => calculateMatchScore(name, queryLower, kind, isExported);
     const fuzzyMatchFn = (name) => {
       const n = name.toLowerCase();
-      const s = stripModulePrefix2(name).toLowerCase();
+      const s = stripModulePrefix(name).toLowerCase();
       return (n.includes(queryLower) || s.includes(queryLower)) && n !== queryLower && s !== queryLower;
     };
     for (const fn of extracted.functions) {
       if (matchFn(fn.name)) {
-        const kind = classifyFunctionKind2(fn.name, fn.returnType);
+        const kind = classifySymbol("function", fn.name, fn.returnType, packageName);
         const score = scoreFn(fn.name, kind, fn.isExported);
         const params = fn.params.map((p) => `${p.name}: ${p.type}`).join(", ");
         const signature = `${fn.name}(${params}): ${fn.returnType}`;
@@ -1763,7 +1896,7 @@ async function depsSearch(packageName, query, options = {}) {
     }
     for (const t of extracted.types) {
       if (matchFn(t.name)) {
-        const kind = classifyFunctionKind2(t.name) === "hook" ? "hook" : t.kind;
+        const kind = classifySymbol("type", t.name, void 0, packageName) === "hook" ? "hook" : t.kind;
         const score = scoreFn(t.name, kind, t.isExported);
         const file = relativeTypeFile(typeFiles, normalizedPkgPath, packageName, t.sourceFile);
         scored.push({ name: t.name, kind, file, signature: t.definition, _score: score });
@@ -1783,7 +1916,7 @@ async function depsSearch(packageName, query, options = {}) {
       const matchedNames = new Set(scored.map((m) => m.name));
       for (const fn of extracted.functions) {
         if (matchedNames.has(fn.name)) continue;
-        const kind = classifyFunctionKind2(fn.name, fn.returnType);
+        const kind = classifySymbol("function", fn.name, fn.returnType, packageName);
         if (exactKinds.has(kind)) continue;
         if (!fuzzyMatchFn(fn.name)) continue;
         const score = scoreFn(fn.name, kind, fn.isExported);
@@ -1797,7 +1930,7 @@ async function depsSearch(packageName, query, options = {}) {
       }
       for (const t of extracted.types) {
         if (matchedNames.has(t.name)) continue;
-        const kind = classifyFunctionKind2(t.name) === "hook" ? "hook" : t.kind;
+        const kind = classifySymbol("type", t.name, void 0, packageName) === "hook" ? "hook" : t.kind;
         if (exactKinds.has(kind)) continue;
         if (!fuzzyMatchFn(t.name)) continue;
         const score = scoreFn(t.name, kind, t.isExported);
@@ -1820,8 +1953,9 @@ async function depsSearch(packageName, query, options = {}) {
       }
     }
     scored.sort((a, b) => b._score - a._score);
-    const filtered = options.kind ? scored.filter((m) => isKindMatch(m.kind, options.kind)) : scored;
+    const filtered = options.kind ? scored.filter((m) => isSemanticKindMatch(m.kind, options.kind)) : scored;
     const matches = filtered.slice(0, MAX_SEARCH_RESULTS).map(({ _score: _, ...match }) => match);
+    const availableKindsWhenEmpty = options.kind && filtered.length === 0 && scored.length > 0 ? [...new Set(scored.map((m) => m.kind))] : void 0;
     const pkgVersion = readPackageJson(packageName, cwd).version;
     const result = {
       version: pkgVersion,
@@ -1833,6 +1967,7 @@ async function depsSearch(packageName, query, options = {}) {
         total: scored.length,
         files: filesSet.size
       },
+      availableKindsWhenEmpty,
       jsFallback: jsFallback || void 0,
       typesSource: resolved.source,
       typesPackage: resolved.typesPackage

package/dist/{chunk-XDFC3IL7.js → chunk-RGRCXEIT.js}

@@ -2337,6 +2337,16 @@ function formatDepsApiText(result, ctx = "cli") {
 `;
     }
     out += `Use ${hint("deps_search", ctx, { "<pacote>": result.package, "<termo>": "*Symbol*" })} para buscar simbolos especificos
+`;
+  }
+  if (result.availableKindsWhenFilteredEmpty && result.availableKindsWhenFilteredEmpty.length > 0) {
+    const kinds = result.availableKindsWhenFilteredEmpty.map((k) => `${k.kind} (${k.count})`).join(", ");
+    out += `
+  Filtro --kind nao encontrou simbolos, mas ha outros tipos disponiveis:
+`;
+    out += `   ${kinds}
+`;
+    out += `   Use ${hint("deps_api", ctx, { "<pacote>": result.package })} sem filtro --kind para ver tudo
 `;
   }
   out += nextSteps("deps_api", ctx);
@@ -2364,6 +2374,16 @@ function formatDepsSearchText(result, ctx = "cli") {
   if (result.matches.length === 0) {
     out += `Nenhum simbolo encontrado para "${result.query}".
 `;
+    if (result.availableKindsWhenEmpty && result.availableKindsWhenEmpty.length > 0) {
+      const kinds = result.availableKindsWhenEmpty.map((k) => `"${k}"`).join(", ");
+      out += `
+  Simbolos encontrados, mas como tipo diferente:
+`;
+      out += `   Kinds disponiveis: ${kinds}
+`;
+      out += `   Tente: ${hint("deps_search", ctx, { "<pacote>": result.package, "<termo>": result.query })} sem filtro --kind
+`;
+    }
     if (result.typesSource === void 0 && !result.jsFallback) {
       out += `
   Pacote "${result.package}" nao possui TypeScript declarations.

package/dist/cli.js

@@ -4,7 +4,7 @@ import {
   depsInfo,
   depsSearch,
   describe
-} from "./chunk-IC74XLRN.js";
+} from "./chunk-KOMBNMGC.js";
 import {
   VERSION,
   area,
@@ -20,7 +20,7 @@ import {
   impact,
   map,
   suggest
-} from "./chunk-XDFC3IL7.js";
+} from "./chunk-RGRCXEIT.js";
 
 // src/cli.ts
 import { resolve } from "path";
@@ -131,7 +131,7 @@ async function main() {
     }
   }
   if (flags.mcp) {
-    const { startMcpServer } = await import("./server-V3N7JTNN.js");
+    const { startMcpServer } = await import("./server-66R2Y3FA.js");
     await startMcpServer();
     return;
   }

package/dist/index.js

@@ -47,7 +47,7 @@ import {
   setFileDescription,
   suggest,
   writeConfig
-} from "./chunk-XDFC3IL7.js";
+} from "./chunk-RGRCXEIT.js";
 export {
   VERSION,
   area,

package/dist/{server-V3N7JTNN.js → server-66R2Y3FA.js}

@@ -3,7 +3,7 @@ import {
   depsInfo,
   depsSearch,
   describe
-} from "./chunk-IC74XLRN.js";
+} from "./chunk-KOMBNMGC.js";
 import {
   VERSION,
   area,
@@ -19,7 +19,7 @@ import {
   map,
   recoveryHint,
   suggest
-} from "./chunk-XDFC3IL7.js";
+} from "./chunk-RGRCXEIT.js";
 
 // src/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@justmpm/ai-tool",
-  "version": "3.20.1",
+  "version": "3.21.0",
   "description": "Ferramenta de análise de dependências e impacto para projetos TypeScript/JavaScript. Usa Skott + Knip internamente. Inclui busca por descrição, integração Git e testes inteligentes.",
   "keywords": [
     "dependency-analysis",