@justmpm/ai-tool 3.21.0 → 3.22.0

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

@@ -20,7 +20,7 @@ import {
   readConfig,
   recoveryHint,
   simplifyType
-} from "./chunk-RGRCXEIT.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) {
@@ -1533,6 +1550,80 @@ function sortByRelevance(items, publicApiNames) {
   });
 }
 
+// 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"]
+  }
+};
+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"]
+  }
+};
+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 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 ?? "" });
+    }
+  }
+  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, "/");
@@ -1681,9 +1772,16 @@ async function depsApi(packageName, options = {}) {
       });
       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(
@@ -1691,6 +1789,7 @@ async function depsApi(packageName, options = {}) {
     );
     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(),
@@ -1705,8 +1804,15 @@ 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,
@@ -1735,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",
@@ -1953,19 +2060,99 @@ async function depsSearch(packageName, query, options = {}) {
       }
     }
     scored.sort((a, b) => b._score - a._score);
+    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 matches = filtered.slice(0, MAX_SEARCH_RESULTS).map(({ _score: _, ...match }) => match);
+    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,

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

@@ -2404,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}
 `;
@@ -2414,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-KOMBNMGC.js";
+} from "./chunk-CFJB2JDZ.js";
 import {
   VERSION,
   area,
@@ -20,7 +20,7 @@ import {
   impact,
   map,
   suggest
-} from "./chunk-RGRCXEIT.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-66R2Y3FA.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-RGRCXEIT.js";
+} from "./chunk-ZNVZNLRQ.js";
 export {
   VERSION,
   area,

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

@@ -3,7 +3,7 @@ import {
   depsInfo,
   depsSearch,
   describe
-} from "./chunk-KOMBNMGC.js";
+} from "./chunk-CFJB2JDZ.js";
 import {
   VERSION,
   area,
@@ -19,7 +19,7 @@ import {
   map,
   recoveryHint,
   suggest
-} from "./chunk-RGRCXEIT.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.21.0",
+  "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",