@justmpm/ai-tool 3.20.1 → 3.22.0

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

@@ -20,7 +20,7 @@ import {
   readConfig,
   recoveryHint,
   simplifyType
-} from "./chunk-XDFC3IL7.js";
+} from "./chunk-ZNVZNLRQ.js";
 
 // src/commands/describe.ts
 var STOPWORDS = /* @__PURE__ */ new Set([
@@ -641,6 +641,23 @@ function resolveEntryPointFile(packageName, entry, cwd) {
     `Nao foi possivel resolver o arquivo de tipos para "${packageName}/${entry}". Tente usar "deps api ${packageName}" para ver todos os exports disponiveis.`
   );
 }
+function getSubExportPaths(packageName, cwd) {
+  try {
+    const pkgPath = resolvePackagePath(packageName, cwd);
+    const pkgJsonPath = join(pkgPath, "package.json");
+    if (!existsSync(pkgJsonPath)) return [];
+    const raw = readFileSync(pkgJsonPath, "utf-8");
+    const pkg = JSON.parse(raw);
+    const exportsField = pkg.exports;
+    if (!exportsField || typeof exportsField !== "object" || exportsField === null) {
+      return [];
+    }
+    const exports = exportsField;
+    return Object.keys(exports).filter((k) => k.startsWith("./")).map((k) => k.slice(2));
+  } catch {
+    return [];
+  }
+}
 function resolveEntryPoints(pkgPath, fields) {
   const raw = [];
   if (fields.types) {
@@ -930,21 +947,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 +984,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 +1448,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)
         });
       }
     }
@@ -1386,38 +1550,106 @@ 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);
+// src/ts/symbol-aliases.ts
+var ZUSTAND_ALIASES = {
+  package: "zustand",
+  aliases: {
+    middleware: ["StateCreator", "persist", "combine", "devtools", "subscribeWithSelector", "Immer", "devtools"],
+    store: ["create", "useStore", "createStore"],
+    state: ["State", "PartialState", "SetState", "GetState", "StoreState"],
+    subscribe: ["subscribe", "subscribeWithSelector"],
+    immer: ["Immer", "createWithImmer"],
+    devtools: ["devtools", "redux"],
+    persist: ["persist", "createPersist", "PersistStorage"]
   }
-  if (/^[A-Za-z]+$/.test(prefix) && /^[A-Z]/.test(prefix)) {
-    return name.slice(dotIdx + 1);
+};
+var MUI_ALIASES = {
+  package: "@mui/material",
+  aliases: {
+    styled: ["styled", "sx", "SxProps", "Theme"],
+    theme: ["Theme", "ThemeOptions", "createTheme", "useTheme", "ThemeProvider"],
+    props: ["Props", "PropsWithRef", "SxProps", "HTMLProps", "ComponentProps"],
+    slot: ["Slot", "Slots", "SlotProps"],
+    component: ["ComponentType", "ElementType", "FC", "ForwardRefExoticComponent"]
   }
-  return name;
+};
+var REACT_ALIASES = {
+  package: "react",
+  aliases: {
+    hook: ["useState", "useEffect", "useContext", "useReducer", "useCallback", "useMemo", "useRef", "useImperativeHandle", "useLayoutEffect", "useDebugValue", "useId", "useTransition", "useDeferredValue", "useSyncExternalStore", "useInsertionEffect", "useFormStatus", "useActionState", "useOptimistic", "use"],
+    component: ["Component", "PureComponent", "FC", "FunctionComponent", "forwardRef", "lazy", "memo", "createContext", "createElement", "cloneElement"],
+    context: ["createContext", "useContext"],
+    element: ["createElement", "cloneElement", "isValidElement"]
+  }
+};
+var FIREBASE_ALIASES = {
+  package: "firebase",
+  aliases: {
+    auth: ["getAuth", "signInWithPopup", "signInWithEmailAndPassword", "createUserWithEmailAndPassword", "signOut", "onAuthStateChanged"],
+    firestore: ["getFirestore", "collection", "doc", "getDoc", "getDocs", "setDoc", "addDoc", "updateDoc", "deleteDoc", "onSnapshot", "query", "where", "orderBy"],
+    storage: ["getStorage", "ref", "uploadBytes", "uploadString", "getDownloadURL", "deleteObject"],
+    messaging: ["getMessaging", "getToken", "onMessage"]
+  }
+};
+var ALIAS_REGISTRY = [
+  ZUSTAND_ALIASES,
+  MUI_ALIASES,
+  REACT_ALIASES,
+  FIREBASE_ALIASES
+];
+function getAliasesForPackage(packageName) {
+  return ALIAS_REGISTRY.find((a) => a.package === packageName);
 }
-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";
-      }
+function resolveConceptualQuery(query, packageName, extracted) {
+  const aliases = getAliasesForPackage(packageName);
+  if (!aliases) return [];
+  const aliasList = aliases.aliases[query.toLowerCase()];
+  if (!aliasList) return [];
+  const results = [];
+  for (const fn of extracted.functions) {
+    if (aliasList.includes(fn.name)) {
+      results.push({ name: fn.name, kind: "function", file: fn.sourceFile ?? "" });
     }
-    return "function";
   }
-  return "function";
+  for (const t of extracted.types) {
+    if (aliasList.includes(t.name)) {
+      results.push({ name: t.name, kind: t.kind, file: t.sourceFile ?? "" });
+    }
+  }
+  return results;
 }
+function isConceptualQuery(query, packageName) {
+  const aliases = getAliasesForPackage(packageName);
+  if (!aliases) return false;
+  return query.toLowerCase() in aliases.aliases;
+}
+
+// src/commands/deps.ts
 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);
+    }
+  }
+  for (const t of extracted.types) {
+    const kind = classifySymbol("type", t.name);
+    if (isSemanticKindMatch(kind, requestedKind)) {
+      kindCounts.set(kind, (kindCounts.get(kind) ?? 0) + 1);
+    }
+  }
+  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 Array.from(kindCounts.entries()).map(([kind, count]) => ({ kind, count })).sort((a, b) => b.count - a.count);
+}
 function relativeTypeFile(typeFiles, normalizedPkgPath, packageName, sourceFile) {
   if (sourceFile) {
     return `${packageName}/${sourceFile}`;
@@ -1427,16 +1659,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,22 +1765,31 @@ 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");
       const realLimit = options.limit ?? 50;
-      filteredFunctions = filteredFunctions.slice(0, realLimit);
-      filteredTypes = filteredTypes.slice(0, realLimit);
-      filteredConstants = filteredConstants.slice(0, realLimit);
+      const realOffset = options.offset ?? 0;
+      filteredFunctions = filteredFunctions.slice(realOffset, realOffset + realLimit);
+      filteredTypes = filteredTypes.slice(realOffset, realOffset + realLimit);
+      filteredConstants = filteredConstants.slice(realOffset, realOffset + realLimit);
+    } else {
+      const realOffset = options.offset ?? 0;
+      const realLimit = options.limit ?? 50;
+      filteredFunctions = filteredFunctions.slice(realOffset, realOffset + realLimit);
+      filteredTypes = filteredTypes.slice(realOffset, realOffset + realLimit);
+      filteredConstants = filteredConstants.slice(realOffset, realOffset + 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")
     );
     const pkgVersion = readPackageJson(packageName, cwd).version;
     const typeFilesMeta = buildTypeFilesMeta(typeFiles, pkgPath);
+    const byKind = options.kind ? computeAvailableKinds(extracted, options.kind) : void 0;
     const result = {
       version: pkgVersion,
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
@@ -1573,8 +1804,16 @@ async function depsApi(packageName, options = {}) {
         types: filteredTypes.length >= (options.limit ?? 50),
         totalFunctions: filteredFunctions.length,
         totalTypes: filteredTypes.length,
-        shown: Math.min(filteredFunctions.length, options.limit ?? 50)
-      } : extracted.truncated,
+        shown: Math.min(filteredFunctions.length, options.limit ?? 50),
+        functionsOffset: options.offset,
+        typesOffset: options.offset,
+        byKind
+      } : {
+        ...extracted.truncated,
+        functionsOffset: options.offset,
+        typesOffset: options.offset
+      },
+      availableKindsWhenFilteredEmpty,
       typeFilesSummary: typeFilesMeta.summary,
       typeFilesPreview: typeFilesMeta.preview,
       jsFallback: jsFallback || void 0,
@@ -1602,7 +1841,8 @@ async function depsApi(packageName, options = {}) {
     throw new Error(`Erro ao executar deps api: ${message}`);
   }
 }
-var MAX_SEARCH_RESULTS = 15;
+var DEFAULT_SEARCH_LIMIT = 15;
+var MAX_SEARCH_LIMIT = 200;
 var AUXILIARY_TYPE_SUFFIXES = [
   "Props",
   "PropsWithRef",
@@ -1739,20 +1979,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 +2003,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 +2023,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 +2037,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,19 +2060,101 @@ 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 matches = filtered.slice(0, MAX_SEARCH_RESULTS).map(({ _score: _, ...match }) => match);
+    const effectiveOffset = options.offset ?? 0;
+    const effectiveLimit = Math.min(options.limit ?? DEFAULT_SEARCH_LIMIT, MAX_SEARCH_LIMIT);
+    const kindCountMap = /* @__PURE__ */ new Map();
+    for (const m of scored) {
+      const key = m.kind;
+      const existing = kindCountMap.get(key);
+      if (existing) {
+        existing.total++;
+      } else {
+        kindCountMap.set(key, { total: 1, shown: 0 });
+      }
+    }
+    const fileCountMap = /* @__PURE__ */ new Map();
+    for (const m of scored) {
+      fileCountMap.set(m.file, (fileCountMap.get(m.file) ?? 0) + 1);
+    }
+    const filtered = options.kind ? scored.filter((m) => isSemanticKindMatch(m.kind, options.kind)) : scored;
+    const pageMatches = filtered.slice(effectiveOffset, effectiveOffset + effectiveLimit);
+    for (const m of pageMatches) {
+      const k = kindCountMap.get(m.kind);
+      if (k) k.shown++;
+    }
+    const byKind = [];
+    for (const [kind, counts] of kindCountMap.entries()) {
+      byKind.push({ kind, total: counts.total, shown: counts.shown });
+    }
+    byKind.sort((a, b) => b.total - a.total);
+    const byFile = Array.from(fileCountMap.entries()).map(([file, count]) => ({ file, count })).sort((a, b) => b.count - a.count).slice(0, 10);
+    const availableKindsWhenEmpty = options.kind && filtered.length === 0 && scored.length > 0 ? [...new Set(scored.map((m) => m.kind))] : void 0;
+    const allMatches = pageMatches.map(({ _score: _, ...match }) => match);
+    if (allMatches.length > 0 && allMatches.length < 3 && !useWildcard) {
+      const isConcept = isConceptualQuery(query, packageName);
+      if (!isConcept) {
+        const aliasResults = resolveConceptualQuery(query, packageName, {
+          functions: extracted.functions,
+          types: extracted.types
+        });
+        for (const r of aliasResults) {
+          if (!allMatches.some((m) => m.name === r.name)) {
+            const fn = extracted.functions.find((f) => f.name === r.name);
+            const t = extracted.types.find((t2) => t2.name === r.name);
+            const signature = fn ? `${fn.name}(${fn.params.map((p) => `${p.name}: ${p.type}`).join(", ")}): ${fn.returnType}` : t?.definition ?? r.name;
+            allMatches.push({ name: r.name, kind: r.kind, file: r.file, signature, fromConcept: query });
+          }
+        }
+      }
+    }
+    if (allMatches.length > 0 && allMatches.length < 3) {
+      const subPaths = getSubExportPaths(packageName, cwd);
+      for (const subPath of subPaths) {
+        try {
+          const subEntryFile = resolveEntryPointFile(packageName, subPath, cwd);
+          const subExtracted = extractPackageApi([subEntryFile], pkgPath, { limit: 200 });
+          const subMatchFn = useWildcard ? (name) => matchWithWildcard(name, query) || matchWithWildcard(stripModulePrefix(name), query) : (name) => {
+            const n = name.toLowerCase();
+            const s = stripModulePrefix(name).toLowerCase();
+            return n === queryLower || s === queryLower;
+          };
+          for (const fn of subExtracted.functions) {
+            if (subMatchFn(fn.name) && !allMatches.some((m) => m.name === fn.name)) {
+              const kind = classifySymbol("function", fn.name, fn.returnType, packageName);
+              const params = fn.params.map((p) => `${p.name}: ${p.type}`).join(", ");
+              const signature = `${fn.name}(${params}): ${fn.returnType}`;
+              const file = relativeTypeFile([subEntryFile], normalizePath(subEntryFile), `${packageName}/${subPath}`, fn.sourceFile);
+              allMatches.push({ name: fn.name, kind, file, signature });
+            }
+          }
+          for (const t of subExtracted.types) {
+            if (subMatchFn(t.name) && !allMatches.some((m) => m.name === t.name)) {
+              const kind = classifySymbol("type", t.name, void 0, packageName) === "hook" ? "hook" : t.kind;
+              const file = relativeTypeFile([subEntryFile], normalizePath(subEntryFile), `${packageName}/${subPath}`, t.sourceFile);
+              allMatches.push({ name: t.name, kind, file, signature: t.definition });
+            }
+          }
+        } catch {
+        }
+        if (allMatches.length >= 10) break;
+      }
+    }
     const pkgVersion = readPackageJson(packageName, cwd).version;
     const result = {
       version: pkgVersion,
       timestamp: (/* @__PURE__ */ new Date()).toISOString(),
       package: packageName,
       query,
-      matches,
+      matches: allMatches,
       summary: {
         total: scored.length,
-        files: filesSet.size
+        files: filesSet.size,
+        shown: allMatches.length,
+        hidden: Math.max(0, filtered.length - effectiveOffset - effectiveLimit),
+        byKind: byKind.length > 1 ? byKind : void 0,
+        byFile: byFile.length > 1 ? byFile : void 0
       },
+      availableKindsWhenEmpty,
       jsFallback: jsFallback || void 0,
       typesSource: resolved.source,
       typesPackage: resolved.typesPackage

package/dist/{chunk-XDFC3IL7.js → chunk-ZNVZNLRQ.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.
@@ -2384,7 +2404,11 @@ function formatDepsSearchText(result, ctx = "cli") {
   }
   for (let i = 0; i < result.matches.length; i++) {
     const match = result.matches[i];
-    out += `${i + 1}. ${match.name} (${match.kind})
+    out += `${i + 1}. ${match.name} (${match.kind})`;
+    if (match.fromConcept) {
+      out += ` [conceito: "${match.fromConcept}"]`;
+    }
+    out += `
 `;
     out += `   ${match.file}
 `;
@@ -2394,12 +2418,36 @@ function formatDepsSearchText(result, ctx = "cli") {
     out += `
 `;
   }
-  const shown = result.matches.length;
+  if (result.summary.byKind && result.summary.byKind.length > 1) {
+    out += `POR KIND:
+`;
+    for (const k of result.summary.byKind) {
+      if (k.total > 0) {
+        const truncInfo = k.shown < k.total ? ` (${k.shown}/${k.total})` : "";
+        out += `  ${k.kind}: ${k.total}${truncInfo}
+`;
+      }
+    }
+  }
+  if (result.summary.byFile && result.summary.byFile.length > 1) {
+    out += `POR ARQUIVO:
+`;
+    for (const f of result.summary.byFile) {
+      if (f.count > 1) {
+        out += `  ${f.file}: ${f.count} matches
+`;
+      }
+    }
+  }
+  const shown = result.summary.shown;
   const total = result.summary.total;
+  const hidden = result.summary.hidden;
   const pluralTotal = total !== 1 ? "s" : "";
   const pluralFiles = result.summary.files !== 1 ? "s" : "";
-  if (shown < total) {
-    out += `${shown} de ${total} resultado${pluralTotal} em ${result.summary.files} arquivo${pluralFiles}
+  if (hidden > 0) {
+    out += `${shown} de ${total} resultado${pluralTotal} (${hidden} hidden)
+`;
+    out += `  em ${result.summary.files} arquivo${pluralFiles}
 `;
   } else {
     out += `${total} resultado${pluralTotal} em ${result.summary.files} arquivo${pluralFiles}

package/dist/cli.js

@@ -4,7 +4,7 @@ import {
   depsInfo,
   depsSearch,
   describe
-} from "./chunk-IC74XLRN.js";
+} from "./chunk-CFJB2JDZ.js";
 import {
   VERSION,
   area,
@@ -20,7 +20,7 @@ import {
   impact,
   map,
   suggest
-} from "./chunk-XDFC3IL7.js";
+} from "./chunk-ZNVZNLRQ.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-QI5WOPV5.js");
     await startMcpServer();
     return;
   }

package/dist/index.js

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

package/dist/{server-V3N7JTNN.js → server-QI5WOPV5.js}

@@ -3,7 +3,7 @@ import {
   depsInfo,
   depsSearch,
   describe
-} from "./chunk-IC74XLRN.js";
+} from "./chunk-CFJB2JDZ.js";
 import {
   VERSION,
   area,
@@ -19,7 +19,7 @@ import {
   map,
   recoveryHint,
   suggest
-} from "./chunk-XDFC3IL7.js";
+} from "./chunk-ZNVZNLRQ.js";
 
 // src/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
@@ -691,7 +691,8 @@ Dica: Se a API estiver truncada, use deps_search com wildcards: "Button" (exato)
 Dica: Para libs muito grandes (MUI, React), use --limit para controlar o output.`,
       inputSchema: {
         package: z.string().min(1).describe("Nome do pacote"),
-        limit: z.number().int().min(1).max(200).optional().describe("Limite de simbolos por tipo (default: 50)"),
+        limit: z.number().int().min(1).max(500).optional().describe("Limite de simbolos por tipo (default: 50)"),
+        offset: z.number().int().min(0).optional().describe("Offset para paginacao (default: 0)"),
         entry: z.string().optional().describe("Sub-export especifico (ex: 'auth' para firebase/firestore)"),
         kind: z.enum(["component", "hook", "function", "type", "interface", "enum", "const"]).optional().describe("Filtrar por tipo de simbolo (component|hook|function|type|interface|enum|const)"),
         format: z.enum(["text", "json"]).default("text").describe("Formato de saida: text (legivel) ou json (estruturado)"),
@@ -711,6 +712,7 @@ Dica: Para libs muito grandes (MUI, React), use --limit para controlar o output.
           format: params.format,
           cwd: params.cwd,
           limit: params.limit,
+          offset: params.offset,
           entry: params.entry,
           kind: params.kind,
           ctx: "mcp"
@@ -747,6 +749,8 @@ Workflow: deps_info (overview) -> deps_api (API completa) -> deps_search (simbol
         package: z.string().min(1).describe("Nome do pacote"),
         query: z.string().min(1).describe("Termo de busca (nome do simbolo)"),
         kind: z.enum(["component", "hook", "function", "type", "interface", "enum", "const"]).optional().describe("Filtrar por tipo de simbolo (component|hook|function|type|interface|enum|const)"),
+        offset: z.number().int().min(0).optional().describe("Offset para paginacao (default: 0)"),
+        limit: z.number().int().min(1).max(200).optional().describe("Limite de resultados (default: 15)"),
         format: z.enum(["text", "json"]).default("text").describe("Formato de saida: text (legivel) ou json (estruturado)"),
         cwd: z.string().optional().describe("Diretorio do projeto a analisar")
       },
@@ -764,6 +768,8 @@ Workflow: deps_info (overview) -> deps_api (API completa) -> deps_search (simbol
           format: params.format,
           cwd: params.cwd,
           kind: params.kind,
+          offset: params.offset,
+          limit: params.limit,
           ctx: "mcp"
         });
         return { content: [{ type: "text", text: result }] };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@justmpm/ai-tool",
-  "version": "3.20.1",
+  "version": "3.22.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",