@justmpm/ai-tool 3.24.0 → 4.0.0

package/dist/chunk-ERMF7MJF.js

@@ -1,2189 +0,0 @@
-import {
-  addSourceFile,
-  detectFileAreas,
-  expandMuiOverrideType,
-  extractExports,
-  extractFunctions,
-  extractTypes,
-  findSimilar,
-  formatDepsApiText,
-  formatDepsInfoText,
-  formatDepsSearchText,
-  formatOutput,
-  getProjectIndexArtifact,
-  getWorkspaceFiles,
-  hint,
-  isFileIgnored,
-  logger,
-  nextSteps,
-  parseCommandOptions,
-  readConfig,
-  recoveryHint,
-  simplifyType
-} from "./chunk-LKP6Z3JC.js";
-
-// src/commands/describe.ts
-var STOPWORDS = /* @__PURE__ */ new Set([
-  // PT-BR
-  "de",
-  "da",
-  "do",
-  "das",
-  "dos",
-  "para",
-  "com",
-  "em",
-  "uma",
-  "um",
-  "o",
-  "a",
-  "os",
-  "as",
-  "no",
-  "na",
-  "nos",
-  "nas",
-  "pelo",
-  "pela",
-  "que",
-  "e",
-  "ou",
-  "se",
-  "ao",
-  "aos",
-  // EN
-  "the",
-  "of",
-  "in",
-  "for",
-  "with",
-  "on",
-  "at",
-  "to",
-  "and",
-  "or",
-  "is",
-  "are",
-  "was",
-  "by",
-  "an"
-]);
-function removeStopwords(words) {
-  const filtered = words.filter((w) => !STOPWORDS.has(w) && w.length > 1);
-  return filtered.length > 0 ? filtered : words;
-}
-function calculatePartialScore(queryWords, searchableText) {
-  if (queryWords.length === 0) return 1;
-  const fullQuery = queryWords.join(" ");
-  if (searchableText.includes(fullQuery)) return 0;
-  let found = 0;
-  for (const word of queryWords) {
-    if (searchableText.includes(word)) {
-      found++;
-    }
-  }
-  return 1 - found / queryWords.length;
-}
-function buildAreaFileMap(allFiles, config) {
-  const map = /* @__PURE__ */ new Map();
-  for (const filePath of allFiles) {
-    if (isFileIgnored(filePath, config)) continue;
-    const fileAreas = detectFileAreas(filePath, config);
-    for (const areaId of fileAreas) {
-      if (!map.has(areaId)) map.set(areaId, []);
-      map.get(areaId).push(filePath);
-    }
-  }
-  return map;
-}
-var GENERIC_PARAMS = /* @__PURE__ */ new Set([
-  "id",
-  "data",
-  "item",
-  "row",
-  "key",
-  "val",
-  "value",
-  "obj",
-  "obj",
-  "arr",
-  "list",
-  "map",
-  "set",
-  "x",
-  "y",
-  "z",
-  "a",
-  "b",
-  "c",
-  "n",
-  "i",
-  "j",
-  "k",
-  "err",
-  "e",
-  "res",
-  "req",
-  "next"
-]);
-function buildSearchableTextAndMatches(candidate, config, areaFileMap, index, queryWords) {
-  const symbolMatches = [];
-  const metadata = `${candidate.id} ${candidate.name} ${candidate.description}`;
-  const keywords = config.areas[candidate.id]?.keywords?.join(" ") ?? "";
-  const areaFiles = areaFileMap.get(candidate.id) ?? [];
-  const fileNames = areaFiles.map((f) => {
-    const name = f.split("/").pop() ?? "";
-    return name.replace(/\.(tsx?|jsx?|mjs|cjs)$/, "");
-  }).join(" ");
-  const symbolNames = [];
-  const symbolSignatures = [];
-  const symbolParams = [];
-  const symbolReturnTypes = [];
-  for (const filePath of areaFiles) {
-    const fileData = index.files[filePath];
-    if (fileData?.symbols) {
-      for (const symbol of fileData.symbols) {
-        if (!symbol.isExported) continue;
-        symbolNames.push(symbol.name);
-        const MAX_SIGNATURE_CHARS = 200;
-        const sig = symbol.signature.length > MAX_SIGNATURE_CHARS ? symbol.signature.slice(0, MAX_SIGNATURE_CHARS) + "..." : symbol.signature;
-        symbolSignatures.push(sig);
-        if (symbol.params && symbol.params.length > 0) {
-          const filteredParams = symbol.params.filter((p) => !GENERIC_PARAMS.has(p));
-          const paramsText = filteredParams.slice(0, 10).join(" ");
-          if (paramsText) {
-            symbolParams.push(paramsText);
-          }
-        }
-        if (symbol.returnType) {
-          symbolReturnTypes.push(symbol.returnType);
-        }
-        for (const word of queryWords) {
-          if (symbol.signature.toLowerCase().includes(word)) {
-            const cleanSig = symbol.signature.replace(/export\s+/g, "").replace(/\s+/g, " ");
-            symbolMatches.push({
-              name: symbol.name,
-              file: filePath,
-              signature: cleanSig,
-              matchType: "signature",
-              matchedText: word
-            });
-          } else if (symbol.params?.some((p) => p.toLowerCase().includes(word))) {
-            const cleanSig = symbol.signature.replace(/export\s+/g, "").replace(/\s+/g, " ");
-            symbolMatches.push({
-              name: symbol.name,
-              file: filePath,
-              signature: cleanSig,
-              matchType: "params",
-              matchedText: word
-            });
-          } else if (symbol.returnType?.toLowerCase().includes(word)) {
-            const cleanSig = symbol.signature.replace(/export\s+/g, "").replace(/\s+/g, " ");
-            symbolMatches.push({
-              name: symbol.name,
-              file: filePath,
-              signature: cleanSig,
-              matchType: "returnType",
-              matchedText: word
-            });
-          }
-        }
-      }
-    }
-  }
-  const searchableText = [
-    metadata,
-    keywords,
-    fileNames,
-    symbolNames.join(" "),
-    symbolSignatures.join(" "),
-    symbolParams.join(" "),
-    symbolReturnTypes.join(" ")
-  ].join(" ").toLowerCase();
-  return { searchableText, symbolMatches };
-}
-async function findAreaMatches(normalizedQuery, candidates, config, cwd) {
-  const allFiles = await getWorkspaceFiles(cwd);
-  const artifact = await getProjectIndexArtifact(cwd, { useCache: true });
-  const index = artifact.index;
-  const areaFileMap = buildAreaFileMap(allFiles, config);
-  const queryWords = removeStopwords(normalizedQuery.split(/\s+/));
-  const matches = [];
-  for (const candidate of candidates) {
-    const { searchableText, symbolMatches } = buildSearchableTextAndMatches(
-      candidate,
-      config,
-      areaFileMap,
-      index,
-      queryWords
-    );
-    const score = calculatePartialScore(queryWords, searchableText);
-    if (score < 0.6) {
-      const areaFiles = areaFileMap.get(candidate.id) ?? [];
-      const seen = /* @__PURE__ */ new Set();
-      const uniqueSymbolMatches = symbolMatches.filter((m) => {
-        const key = `${m.file}:${m.signature}`;
-        if (seen.has(key)) return false;
-        seen.add(key);
-        return true;
-      });
-      matches.push({
-        id: candidate.id,
-        name: candidate.name,
-        description: candidate.description || "Sem descricao",
-        files: areaFiles,
-        fileCount: areaFiles.length,
-        score,
-        symbolMatches: uniqueSymbolMatches.length > 0 ? uniqueSymbolMatches : void 0
-      });
-    }
-  }
-  return matches.sort((a, b) => a.score - b.score);
-}
-async function describe(query, options = {}) {
-  const { cwd, format } = parseCommandOptions(options);
-  const ctx = options.ctx || "cli";
-  if (!query || query.trim().length === 0) {
-    throw new Error("Query \xE9 obrigat\xF3ria. Exemplo: ai-tool describe 'autentica\xE7\xE3o'");
-  }
-  try {
-    const config = readConfig(cwd);
-    const hasAreas = Object.keys(config.areas).length > 0;
-    if (!hasAreas) {
-      let out = `\u26A0\uFE0F Nenhuma area configurada neste projeto.
-
-`;
-      out += `O comando describe busca em areas configuradas.
-`;
-      out += `Para configurar areas:
-`;
-      out += `   1. ${hint("areas_init", ctx)} - gerar arquivo de configuracao
-`;
-      out += `   2. Edite .analyze/areas.config.json com as areas do projeto
-
-`;
-      out += `Enquanto isso, use:
-`;
-      out += `   \u2192 ${hint("find", ctx)} - buscar simbolos no codigo
-`;
-      out += `   \u2192 ${hint("map", ctx)} - ver estrutura do projeto
-`;
-      return out;
-    }
-    const normalizedQuery = query.toLowerCase().trim();
-    const candidates = Object.entries(config.areas).map(([id, area]) => ({
-      id,
-      name: area.name,
-      description: area.description || ""
-    }));
-    const matches = await findAreaMatches(normalizedQuery, candidates, config, cwd);
-    const suggestions = [];
-    if (matches.length === 0) {
-      const similarAreaIds = findSimilar(
-        normalizedQuery,
-        candidates.map((c) => c.id),
-        { maxDistance: 2, limit: 3 }
-      );
-      const similarNames = findSimilar(
-        normalizedQuery,
-        candidates.map((c) => c.name),
-        { maxDistance: 2, limit: 3 }
-      );
-      suggestions.push(
-        ...similarAreaIds.map((id) => `\u2192 ${hint("describe", ctx, { "<termo>": id })}`),
-        ...similarNames.map((name) => `\u2192 ${hint("describe", ctx, { "<termo>": `"${name}"` })}`)
-      );
-    }
-    const result = {
-      version: "1.0.0",
-      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-      query,
-      areas: matches,
-      suggestions: suggestions.length > 0 ? suggestions : void 0
-    };
-    return formatOutput(result, format, (r) => formatDescribeText(r, ctx));
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    throw new Error(`Erro ao executar describe: ${message}`);
-  }
-}
-function formatDescribeText(result, ctx = "cli") {
-  let out = "";
-  if (result.areas.length === 0) {
-    out += `\u274C Nenhuma area encontrada para: "${result.query}"
-
-`;
-    if (result.suggestions && result.suggestions.length > 0) {
-      out += `\u{1F4A1} Voce quis dizer?
-`;
-      for (const suggestion of result.suggestions) {
-        out += `   ${suggestion}
-`;
-      }
-      out += `
-`;
-    }
-    out += `\u{1F4D6} Dicas:
-`;
-    out += `   \u2192 ${hint("areas", ctx)} - listar todas as areas disponiveis
-`;
-    out += `   \u2192 ${hint("find", ctx)} - buscar simbolos por nome
-`;
-    return out;
-  }
-  out += `\u{1F50D} Busca: "${result.query}"
-
-`;
-  for (const area of result.areas) {
-    out += `## ${area.name} (${area.id})
-`;
-    out += `${area.description}
-`;
-    out += `\u{1F4C1} ${area.fileCount} arquivo(s)
-`;
-    if (area.symbolMatches && area.symbolMatches.length > 0) {
-      out += `
-\u{1F517} Simbolos que correspondem a busca:
-`;
-      const byFile = /* @__PURE__ */ new Map();
-      for (const match of area.symbolMatches) {
-        if (!byFile.has(match.file)) byFile.set(match.file, []);
-        byFile.get(match.file).push(match);
-      }
-      const MAX_SYMBOLS = 5;
-      let count = 0;
-      for (const [file, matches] of byFile) {
-        for (const match of matches) {
-          if (count >= MAX_SYMBOLS) break;
-          const matchLabel = match.matchType === "signature" ? "\u21B3" : match.matchType === "params" ? "\u2192 (param)" : "\u2192 (return)";
-          out += `   ${matchLabel} ${file}
-`;
-          out += `      ${match.signature}
-`;
-          count++;
-        }
-        if (count >= MAX_SYMBOLS) break;
-      }
-      if (area.symbolMatches.length > MAX_SYMBOLS) {
-        out += `   ... e mais ${area.symbolMatches.length - MAX_SYMBOLS} simbolo(s)
-`;
-      }
-    }
-    out += "\n";
-    if (area.files.length > 0) {
-      const MAX_FILES = 5;
-      const filesToShow = area.files.slice(0, MAX_FILES);
-      const remaining = area.files.length - filesToShow.length;
-      out += `Arquivos:
-`;
-      for (const file of filesToShow) {
-        out += `   \u2022 ${file}
-`;
-      }
-      if (remaining > 0) {
-        out += `   ... e mais ${remaining} arquivo(s)
-`;
-        out += `   \u2192 ${hint("area", ctx, { "<nome>": area.id })} - ver todos
-`;
-      }
-      out += "\n";
-    }
-  }
-  out += nextSteps("describe", ctx);
-  return out;
-}
-
-// src/commands/deps.ts
-import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
-import { join as join3 } from "path";
-
-// src/ts/package-reader.ts
-import { readFileSync, existsSync, readdirSync, statSync } from "fs";
-import { join, resolve } from "path";
-function resolvePackagePath(packageName, cwd) {
-  const nmDir = join(cwd, "node_modules", packageName);
-  if (existsSync(nmDir)) {
-    logger.debug(`Pacote "${packageName}" resolvido em: ${nmDir}`);
-    return resolve(nmDir);
-  }
-  throw new Error(
-    `Pacote "${packageName}" nao encontrado em node_modules.
-  \u2022 Verifique se o pacote esta instalado no projeto
-  \u2022 Verifique se voce esta no diretorio correto: ${cwd}`
-  );
-}
-function readPackageJson(packageName, cwd) {
-  const pkgPath = resolvePackagePath(packageName, cwd);
-  const pkgJsonPath = join(pkgPath, "package.json");
-  if (!existsSync(pkgJsonPath)) {
-    throw new Error(
-      `package.json nao encontrado em: ${pkgJsonPath}
-  \u2022 O pacote "${packageName}" pode estar corrompido.`
-    );
-  }
-  const raw = readFileSync(pkgJsonPath, "utf-8");
-  const pkg = JSON.parse(raw);
-  const name = getStringField(pkg, "name") ?? packageName;
-  const version = getStringField(pkg, "version") ?? "0.0.0";
-  const description = getStringField(pkg, "description");
-  const main = getStringField(pkg, "main");
-  const types = getStringField(pkg, "types");
-  const typings = getStringField(pkg, "typings");
-  const exportsField = pkg.exports;
-  const module = getStringField(pkg, "module");
-  const repository = extractRepository(pkg);
-  const homepage = getStringField(pkg, "homepage");
-  const license = getStringField(pkg, "license");
-  const author = extractAuthor(pkg);
-  const dependencies = pkg.dependencies ?? {};
-  const peerDependencies = pkg.peerDependencies ?? {};
-  const hasTypes = !!(types || typings || exportsField);
-  const typesSource = hasTypes ? "builtin" : void 0;
-  const entryPoints = resolveEntryPoints(pkgPath, {
-    main,
-    types,
-    typings,
-    exportsField,
-    module
-  });
-  return {
-    version,
-    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
-    package: packageName,
-    resolvedPath: pkgPath,
-    info: {
-      name,
-      version,
-      description,
-      main,
-      types,
-      typings,
-      exports: exportsField,
-      module,
-      repository,
-      homepage,
-      license,
-      author,
-      dependencies,
-      peerDependencies,
-      hasTypes,
-      typesSource
-    },
-    entryPoints
-  };
-}
-function resolveTypeFilesWithSource(packageName, cwd) {
-  const pkgPath = resolvePackagePath(packageName, cwd);
-  const pkgJsonPath = join(pkgPath, "package.json");
-  if (!existsSync(pkgJsonPath)) {
-    throw new Error(`package.json nao encontrado em: ${pkgJsonPath}`);
-  }
-  const raw = readFileSync(pkgJsonPath, "utf-8");
-  const pkg = JSON.parse(raw);
-  const candidates = [];
-  const types = getStringField(pkg, "types");
-  if (types) {
-    candidates.push(join(pkgPath, types));
-  }
-  const typings = getStringField(pkg, "typings");
-  if (typings && !candidates.includes(join(pkgPath, typings))) {
-    candidates.push(join(pkgPath, typings));
-  }
-  const exportsField = pkg.exports;
-  if (exportsField && typeof exportsField === "object" && exportsField !== null) {
-    const exportsEntries = resolveExportsTypes(pkgPath, exportsField);
-    for (const entry of exportsEntries) {
-      if (!candidates.includes(entry)) {
-        candidates.push(entry);
-      }
-    }
-  }
-  const module = getStringField(pkg, "module");
-  if (module && !candidates.length) {
-    const dts = convertToDts(join(pkgPath, module));
-    if (dts) candidates.push(dts);
-  }
-  const main = getStringField(pkg, "main");
-  if (main && !candidates.length) {
-    const dts = convertToDts(join(pkgPath, main));
-    if (dts) candidates.push(dts);
-  }
-  if (!candidates.length) {
-    const fallback = join(pkgPath, "index.d.ts");
-    candidates.push(fallback);
-  }
-  const hasCtsMtsOnly = candidates.some(
-    (c) => (c.endsWith(".d.cts") || c.endsWith(".d.mts")) && !c.endsWith(".d.ts")
-  );
-  if (hasCtsMtsOnly) {
-    const dtsEquivalent = join(pkgPath, "index.d.ts");
-    if (!candidates.includes(dtsEquivalent)) {
-      candidates.push(dtsEquivalent);
-    }
-  }
-  const existing = candidates.filter((f) => existsSync(f));
-  const allCtsOrMts = existing.length > 0 && existing.every(
-    (f) => f.endsWith(".d.cts") || f.endsWith(".d.mts")
-  );
-  const hasReExports = existing.length > 0 && existing.length <= 8;
-  const shouldScan = allCtsOrMts || hasReExports;
-  if (shouldScan) {
-    const candidatesSet = new Set(existing.map((f) => f.toLowerCase()));
-    const scanned2 = scanForDeclarationFiles(pkgPath, new Set(candidatesSet));
-    for (const file of scanned2) {
-      if (!candidatesSet.has(file.toLowerCase())) {
-        candidates.push(file);
-      }
-    }
-    const allExisting = candidates.filter((f) => existsSync(f));
-    existing.length = 0;
-    existing.push(...allExisting);
-  }
-  if (existing.length > 0) {
-    logger.debug(`Type files para "${packageName}":`, existing);
-    return { files: existing, source: "builtin" };
-  }
-  if (!packageName.startsWith("@types/")) {
-    const typesPackageName = `@types/${packageName}`;
-    try {
-      const typesPkgPath = resolvePackagePath(typesPackageName, cwd);
-      const typesPkgJsonPath = join(typesPkgPath, "package.json");
-      if (existsSync(typesPkgJsonPath)) {
-        const typesRaw = readFileSync(typesPkgJsonPath, "utf-8");
-        const typesPkg = JSON.parse(typesRaw);
-        const typesCandidates = [];
-        const typesField = getStringField(typesPkg, "types");
-        if (typesField) {
-          typesCandidates.push(join(typesPkgPath, typesField));
-        }
-        const typingsField = getStringField(typesPkg, "typings");
-        if (typingsField && !typesCandidates.length) {
-          typesCandidates.push(join(typesPkgPath, typingsField));
-        }
-        if (!typesCandidates.length) {
-          typesCandidates.push(join(typesPkgPath, "index.d.ts"));
-        }
-        const typesExisting = typesCandidates.filter((f) => existsSync(f));
-        if (typesExisting.length > 0) {
-          logger.debug(
-            `Type files para "${packageName}" via @types:`,
-            typesExisting
-          );
-          return {
-            files: typesExisting,
-            source: "@types",
-            typesPackage: typesPackageName
-          };
-        }
-      }
-    } catch {
-      logger.debug(
-        `@types/${packageName} n\xE3o encontrado, tentando JS fallback`
-      );
-    }
-  }
-  const scanned = scanForDeclarationFiles(pkgPath, /* @__PURE__ */ new Set(), true);
-  for (const file of scanned) {
-    candidates.push(file);
-  }
-  if (scanned.length === 0) {
-    const jsCandidates = resolveJsFiles(pkgPath, pkg);
-    candidates.push(...jsCandidates);
-  }
-  const jsExisting = candidates.filter((f) => existsSync(f));
-  if (jsExisting.length === 0) {
-    throw new Error(
-      `O pacote "${packageName}" nao possui TypeScript declarations.
-  \u2022 Verifique se o pacote tem um campo "types" ou "typings" no package.json
-  \u2022 Alguns pacotes distribuem tipos separados (ex: @types/nome-do-pacote)
-  \u2022 Pacote resolvido em: ${pkgPath}`
-    );
-  }
-  logger.debug(`Type files para "${packageName}" (JS fallback):`, jsExisting);
-  return { files: jsExisting, source: "js-fallback" };
-}
-function resolveEntryPointFile(packageName, entry, cwd) {
-  const pkgPath = resolvePackagePath(packageName, cwd);
-  const pkgJsonPath = join(pkgPath, "package.json");
-  if (!existsSync(pkgJsonPath)) {
-    throw new Error(`package.json nao encontrado em: ${pkgJsonPath}`);
-  }
-  const raw = readFileSync(pkgJsonPath, "utf-8");
-  const pkg = JSON.parse(raw);
-  const exportsField = pkg.exports;
-  if (!exportsField || typeof exportsField !== "object" || exportsField === null) {
-    throw new Error(
-      `Pacote "${packageName}" nao possui campo "exports" no package.json`
-    );
-  }
-  const exports = exportsField;
-  const exportKey = `./${entry}`;
-  const exportValue = exports[exportKey];
-  if (!exportValue || typeof exportValue !== "object" || exportValue === null) {
-    throw new Error(
-      `Sub-export "./${entry}" nao encontrado em "${packageName}". Exports disponiveis: ${Object.keys(exports).filter((k) => k.startsWith("./")).join(", ")}`
-    );
-  }
-  const nested = exportValue;
-  const conditions = ["types", "typings", "import", "default"];
-  for (const condition of conditions) {
-    const value = nested[condition];
-    if (typeof value === "string") {
-      const candidate = join(pkgPath, value);
-      if (value.endsWith(".js") || value.endsWith(".mjs") || value.endsWith(".cjs")) {
-        const dts = convertToDts(candidate);
-        if (dts && existsSync(dts)) return dts;
-      }
-      if (existsSync(candidate)) return candidate;
-    }
-  }
-  throw new Error(
-    `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) {
-    raw.push({ condition: "types", path: join(pkgPath, fields.types), type: "types" });
-  }
-  if (fields.typings) {
-    raw.push({ condition: "typings", path: join(pkgPath, fields.typings), type: "types" });
-  }
-  if (fields.main) {
-    raw.push({ condition: "main", path: join(pkgPath, fields.main), type: "main" });
-  }
-  if (fields.module) {
-    raw.push({ condition: "module", path: join(pkgPath, fields.module), type: "module" });
-  }
-  if (fields.exportsField) {
-    for (const [condition, value] of Object.entries(fields.exportsField)) {
-      if (typeof value === "string") {
-        raw.push({ condition, path: join(pkgPath, value), type: classifyExportCondition(condition) });
-      } else if (typeof value === "object" && value !== null) {
-        const nested = value;
-        for (const [nestedCondition, nestedValue] of Object.entries(nested)) {
-          if (typeof nestedValue === "string") {
-            const fullCondition = condition === "." ? nestedCondition : `${condition}/${nestedCondition}`;
-            raw.push({
-              condition: fullCondition,
-              path: join(pkgPath, nestedValue),
-              type: classifyExportCondition(nestedCondition)
-            });
-          }
-        }
-      }
-    }
-  }
-  return deduplicateEntryPoints(raw);
-}
-function deduplicateEntryPoints(points) {
-  const seen = /* @__PURE__ */ new Map();
-  for (const point of points) {
-    const normalizedPath = point.path.toLowerCase();
-    const existing = seen.get(normalizedPath);
-    if (existing) {
-      const existingConditions = new Set(existing.condition.split(", "));
-      const newConditions = point.condition.split(", ");
-      for (const c of newConditions) {
-        existingConditions.add(c);
-      }
-      existing.condition = Array.from(existingConditions).join(", ");
-    } else {
-      seen.set(normalizedPath, { ...point });
-    }
-  }
-  return Array.from(seen.values());
-}
-function classifyExportCondition(condition) {
-  if (condition === "types" || condition === "typings") return "types";
-  if (condition === "import") return "import";
-  if (condition === "require") return "require";
-  if (condition === "default" || condition === ".") return "default";
-  if (condition === "module") return "module";
-  return "default";
-}
-function resolveExportsTypes(pkgPath, exportsField) {
-  const results = [];
-  for (const [, value] of Object.entries(exportsField)) {
-    if (typeof value === "string") {
-      if (value.endsWith(".d.ts") || value.endsWith(".d.mts") || value.endsWith(".d.cts")) {
-        results.push(join(pkgPath, value));
-      }
-    } else if (typeof value === "object" && value !== null) {
-      const nested = value;
-      if (typeof nested.types === "string") {
-        results.push(join(pkgPath, nested.types));
-      }
-      if (typeof nested.typings === "string") {
-        results.push(join(pkgPath, nested.typings));
-      }
-    }
-  }
-  return results;
-}
-function convertToDts(filePath) {
-  if (filePath.endsWith(".mjs")) return filePath.replace(/\.mjs$/, ".d.mts");
-  if (filePath.endsWith(".cjs")) return filePath.replace(/\.cjs$/, ".d.cts");
-  if (filePath.endsWith(".js")) return filePath.replace(/\.js$/, ".d.ts");
-  return void 0;
-}
-function getStringField(obj, field, fallback) {
-  const value = obj[field];
-  if (typeof value === "string") return value;
-  return fallback;
-}
-function extractRepository(pkg) {
-  const repo = pkg.repository;
-  if (typeof repo === "string") return repo;
-  if (typeof repo === "object" && repo !== null) {
-    const url = repo.url;
-    if (typeof url === "string") return url;
-  }
-  return void 0;
-}
-function extractAuthor(pkg) {
-  const author = pkg.author;
-  if (typeof author === "string") return author;
-  if (typeof author === "object" && author !== null) {
-    const name = author.name;
-    if (typeof name === "string") return name;
-  }
-  return void 0;
-}
-function resolveJsFiles(pkgPath, pkg) {
-  const results = [];
-  const main = getStringField(pkg, "main");
-  if (main) {
-    const mainPath = join(pkgPath, main);
-    if (existsSync(mainPath)) {
-      results.push(mainPath);
-    }
-  }
-  const module = getStringField(pkg, "module");
-  if (module && results.length === 0) {
-    const modulePath = join(pkgPath, module);
-    if (existsSync(modulePath)) {
-      results.push(modulePath);
-    }
-  }
-  const exportsField = pkg.exports;
-  if (exportsField && typeof exportsField === "object" && exportsField !== null && results.length === 0) {
-    const exports = exportsField;
-    const dotExport = exports["."];
-    if (typeof dotExport === "object" && dotExport !== null) {
-      const nested = dotExport;
-      for (const condition of ["import", "default"]) {
-        const path = nested[condition];
-        if (typeof path === "string") {
-          const fullPath = join(pkgPath, path);
-          if (existsSync(fullPath)) {
-            results.push(fullPath);
-            break;
-          }
-        }
-      }
-    }
-    if (typeof dotExport === "string" && results.length === 0) {
-      const fullPath = join(pkgPath, dotExport);
-      if (existsSync(fullPath)) {
-        results.push(fullPath);
-      }
-    }
-  }
-  if (results.length === 0) {
-    const indexPath = join(pkgPath, "index.js");
-    if (existsSync(indexPath)) {
-      results.push(indexPath);
-    }
-  }
-  return results;
-}
-function scanForDeclarationFiles(packagePath, existingFiles, allowJs = false) {
-  const MAX_FILES = 300;
-  const MAX_DEPTH = 3;
-  const MAX_JS_SIZE = 50 * 1024;
-  const MAX_INDEX_EXTRA = 200;
-  const results = [];
-  const pendingIndexDirs = [];
-  function scan(dir, depth) {
-    if (depth > MAX_DEPTH || results.length >= MAX_FILES) return;
-    try {
-      const entries = readdirSync(dir);
-      for (const entry of entries) {
-        if (results.length >= MAX_FILES) break;
-        if (entry === "node_modules" || entry.startsWith(".")) continue;
-        const fullPath = join(dir, entry);
-        try {
-          const stat = statSync(fullPath);
-          if (stat.isDirectory()) {
-            const subIndexPath = join(fullPath, "index.d.ts");
-            const hasSubIndex = existsSync(subIndexPath) && !existingFiles.has(subIndexPath.toLowerCase());
-            scan(fullPath, depth + 1);
-            if (results.length >= MAX_FILES && hasSubIndex) {
-              pendingIndexDirs.push(subIndexPath);
-            }
-          } else {
-            const isJsFile = allowJs && (entry.endsWith(".js") || entry.endsWith(".mjs") || entry.endsWith(".cjs"));
-            const isDtFile = entry.endsWith(".d.ts") || entry.endsWith(".d.mts") || entry.endsWith(".d.cts");
-            if ((isDtFile || isJsFile) && !existingFiles.has(fullPath.toLowerCase())) {
-              try {
-                const content = readFileSync(fullPath, "utf-8");
-                if (isJsFile) {
-                  if (content.length > MAX_JS_SIZE) continue;
-                }
-                results.push(fullPath);
-                existingFiles.add(fullPath.toLowerCase());
-              } catch {
-              }
-            }
-          }
-        } catch {
-        }
-      }
-    } catch {
-    }
-  }
-  scan(packagePath, 0);
-  for (const indexPath of pendingIndexDirs) {
-    if (results.length >= MAX_FILES + MAX_INDEX_EXTRA) break;
-    if (!existingFiles.has(indexPath.toLowerCase())) {
-      results.push(indexPath);
-      existingFiles.add(indexPath.toLowerCase());
-    }
-  }
-  collectRemainingIndexFiles(packagePath, existingFiles, results, MAX_FILES + MAX_INDEX_EXTRA);
-  return deduplicateCjsEsmPairs(results);
-}
-function deduplicateCjsEsmPairs(typeFiles) {
-  if (typeFiles.length <= 1) return typeFiles;
-  const moduleSegments = /* @__PURE__ */ new Set(["esm", "cjs", "lib", "es", "dist"]);
-  const groups = /* @__PURE__ */ new Map();
-  for (const filePath of typeFiles) {
-    const baseName = computeBaseName(filePath, moduleSegments);
-    const existing = groups.get(baseName);
-    if (existing) {
-      existing.push(filePath);
-    } else {
-      groups.set(baseName, [filePath]);
-    }
-  }
-  const deduplicated = [];
-  let removedCount = 0;
-  for (const [, group] of groups) {
-    if (group.length === 1) {
-      deduplicated.push(group[0]);
-      continue;
-    }
-    const esmFile = pickEsmVariant(group);
-    deduplicated.push(esmFile);
-    removedCount += group.length - 1;
-  }
-  if (removedCount > 0) {
-    logger.debug(
-      `Deduplica\xE7\xE3o CJS/ESM: ${typeFiles.length} \u2192 ${deduplicated.length} type files (removidos ${removedCount} duplicatas)`
-    );
-  }
-  return deduplicated;
-}
-function computeBaseName(filePath, moduleSegments) {
-  const parts = filePath.replace(/\\/g, "/").split("/");
-  const filtered = [];
-  for (const part of parts) {
-    if (moduleSegments.has(part)) continue;
-    filtered.push(part);
-  }
-  return filtered.join("/");
-}
-function pickEsmVariant(group) {
-  const mtsFile = group.find((f) => f.endsWith(".d.mts"));
-  if (mtsFile) return mtsFile;
-  const normalizedPath = group.find((f) => {
-    const lower = f.replace(/\\/g, "/").toLowerCase();
-    return lower.includes("/esm/") || lower.endsWith("/es") || lower.includes("/es/");
-  });
-  if (normalizedPath) return normalizedPath;
-  return group[0];
-}
-function collectRemainingIndexFiles(packagePath, existingFiles, results, maxFiles) {
-  try {
-    const entries = readdirSync(packagePath);
-    for (const entry of entries) {
-      if (results.length >= maxFiles) break;
-      if (entry === "node_modules" || entry.startsWith(".")) continue;
-      const fullPath = join(packagePath, entry);
-      try {
-        const stat = statSync(fullPath);
-        if (!stat.isDirectory()) continue;
-        const indexPath = join(fullPath, "index.d.ts");
-        if (existsSync(indexPath) && !existingFiles.has(indexPath.toLowerCase())) {
-          results.push(indexPath);
-          existingFiles.add(indexPath.toLowerCase());
-        }
-      } catch {
-      }
-    }
-  } catch {
-  }
-}
-
-// src/ts/package-extractor.ts
-import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
-import { dirname, join as join2, resolve as resolve2 } from "path";
-import { Project } from "ts-morph";
-
-// 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);
-  return REACT_COMPONENT_FACTORIES.has(cleanName);
-}
-function stripModulePrefix(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);
-  }
-  if (/^[A-Za-z]+$/.test(prefix) && /^[A-Z]/.test(prefix)) {
-    return name.slice(dotIdx + 1);
-  }
-  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"];
-var JS_EXTENSIONS = [".js", ".cjs", ".mjs", ".ts", ".cts", ".mts"];
-function findNodeModulesDir(packagePath) {
-  const normalizedPath = packagePath.replace(/\\/g, "/");
-  const idx = normalizedPath.lastIndexOf("node_modules");
-  if (idx === -1) return dirname(packagePath);
-  return resolve2(packagePath.substring(0, idx + "node_modules".length));
-}
-function resolveModuleSpecifier(specifier, fromFilePath, nodeModulesDir) {
-  if (specifier.startsWith("./") || specifier.startsWith("../")) {
-    return resolveRelativePath(specifier, fromFilePath);
-  }
-  return resolveBareModule(specifier, nodeModulesDir);
-}
-function stripJsExtension(specifier) {
-  for (const ext of JS_EXTENSIONS) {
-    if (specifier.endsWith(ext)) {
-      return specifier.slice(0, -ext.length);
-    }
-  }
-  return specifier;
-}
-function resolveRelativePath(specifier, fromFilePath) {
-  const dir = dirname(fromFilePath);
-  const cleanSpecifier = stripJsExtension(specifier);
-  for (const ext of TYPE_DECLARATION_EXTENSIONS) {
-    const candidate = resolve2(dir, cleanSpecifier + ext);
-    if (existsSync2(candidate)) return candidate;
-  }
-  const asIs = resolve2(dir, specifier);
-  if (existsSync2(asIs)) return asIs;
-  for (const ext of TYPE_DECLARATION_EXTENSIONS) {
-    const indexCandidate = resolve2(dir, cleanSpecifier, "index" + ext);
-    if (existsSync2(indexCandidate)) return indexCandidate;
-  }
-  return void 0;
-}
-function convertToDts2(filePath) {
-  if (filePath.endsWith(".mjs")) return filePath.replace(/\.mjs$/, ".d.mts");
-  if (filePath.endsWith(".cjs")) return filePath.replace(/\.cjs$/, ".d.cts");
-  if (filePath.endsWith(".js")) return filePath.replace(/\.js$/, ".d.ts");
-  return void 0;
-}
-function resolveBareModule(specifier, nodeModulesDir) {
-  const pkgDir = resolve2(nodeModulesDir, specifier);
-  const pkgJsonPath = join2(pkgDir, "package.json");
-  if (!existsSync2(pkgJsonPath)) return void 0;
-  try {
-    const raw = readFileSync2(pkgJsonPath, "utf-8");
-    const pkg = JSON.parse(raw);
-    const exportsField = pkg.exports;
-    if (exportsField && typeof exportsField === "object" && exportsField !== null) {
-      const exports = exportsField;
-      const dotExport = exports["."];
-      if (typeof dotExport === "object" && dotExport !== null) {
-        const nested = dotExport;
-        for (const condition of ["types", "typings", "import", "default"]) {
-          const value = nested[condition];
-          if (typeof value === "string") {
-            const candidate = join2(pkgDir, value);
-            if (existsSync2(candidate)) return candidate;
-            const dts = convertToDts2(candidate);
-            if (dts && existsSync2(dts)) return dts;
-          }
-        }
-      }
-      if (typeof dotExport === "string") {
-        const candidate = join2(pkgDir, dotExport);
-        if (existsSync2(candidate)) return candidate;
-        const dts = convertToDts2(candidate);
-        if (dts && existsSync2(dts)) return dts;
-      }
-    }
-    const typesField = pkg.types;
-    if (typeof typesField === "string") {
-      const candidate = join2(pkgDir, typesField);
-      if (existsSync2(candidate)) return candidate;
-    }
-    const typingsField = pkg.typings;
-    if (typeof typingsField === "string") {
-      const candidate = join2(pkgDir, typingsField);
-      if (existsSync2(candidate)) return candidate;
-    }
-    const mainField = pkg.main;
-    if (typeof mainField === "string") {
-      const candidate = join2(pkgDir, mainField);
-      const dts = convertToDts2(candidate);
-      if (dts && existsSync2(dts)) return dts;
-    }
-    const indexDts = join2(pkgDir, "index.d.ts");
-    if (existsSync2(indexDts)) return indexDts;
-  } catch {
-    logger.debug(`Falha ao ler package.json em: ${pkgJsonPath}`);
-  }
-  return void 0;
-}
-function followReExports(project, sourceFiles, visited, nodeModulesDir, depth) {
-  if (depth >= MAX_REEXPORT_DEPTH || visited.size >= MAX_TOTAL_FILES) return [];
-  const newFiles = [];
-  const namedReExportFiles = [];
-  let followedCount = 0;
-  let failedCount = 0;
-  let skippedCount = 0;
-  for (const sourceFile of sourceFiles) {
-    if (visited.size >= MAX_TOTAL_FILES) break;
-    for (const exportDecl of sourceFile.getExportDeclarations()) {
-      if (visited.size >= MAX_TOTAL_FILES) break;
-      const specifier = exportDecl.getModuleSpecifierValue();
-      if (!specifier) continue;
-      const filePath = sourceFile.getFilePath();
-      let resolvedPath;
-      try {
-        const resolvedFile = exportDecl.getModuleSpecifierSourceFile();
-        if (resolvedFile) {
-          resolvedPath = resolvedFile.getFilePath();
-          if (resolvedPath.endsWith(".js") || resolvedPath.endsWith(".mjs") || resolvedPath.endsWith(".cjs")) {
-            const dtsPath = convertToDts2(resolvedPath);
-            if (dtsPath && existsSync2(dtsPath)) {
-              resolvedPath = dtsPath;
-            }
-          }
-        }
-      } catch {
-      }
-      if (!resolvedPath) {
-        resolvedPath = resolveModuleSpecifier(specifier, filePath, nodeModulesDir);
-      }
-      if (!resolvedPath || visited.has(resolvedPath)) {
-        if (resolvedPath && visited.has(resolvedPath)) skippedCount++;
-        if (!resolvedPath) failedCount++;
-        continue;
-      }
-      visited.add(resolvedPath);
-      try {
-        if (!existsSync2(resolvedPath)) {
-          failedCount++;
-          continue;
-        }
-        const isNamespace = exportDecl.isNamespaceExport();
-        const isNamedReExport = !isNamespace && exportDecl.getNamedExports().length > 0;
-        logger.debug(
-          `${isNamespace ? "Namespace re-export" : "Named re-export"} (depth ${depth}): ${specifier} -> ${resolvedPath}`
-        );
-        const newSourceFile = addSourceFile(project, resolvedPath);
-        followedCount++;
-        if (isNamespace) {
-          newFiles.push(newSourceFile);
-        } else if (isNamedReExport) {
-          namedReExportFiles.push(newSourceFile);
-        }
-      } catch (err) {
-        failedCount++;
-        logger.debug(`Falha ao seguir re-export "${specifier}":`, err);
-      }
-    }
-  }
-  if (followedCount > 0 || failedCount > 0) {
-    logger.debug(
-      `Re-export stats (depth ${depth}): ${followedCount} followed, ${failedCount} failed, ${skippedCount} skipped (visited: ${visited.size}/${MAX_TOTAL_FILES})`
-    );
-  }
-  if (newFiles.length > 0) {
-    const deeperFiles = followReExports(
-      project,
-      newFiles,
-      visited,
-      nodeModulesDir,
-      depth + 1
-    );
-    newFiles.push(...deeperFiles);
-  }
-  return [...newFiles, ...namedReExportFiles];
-}
-function resolveDefaultReExportNames(originalFiles, allSourceFiles, publicApiNames) {
-  const fileMap = /* @__PURE__ */ new Map();
-  for (const sf of allSourceFiles) {
-    fileMap.set(sf.getFilePath().replace(/\\/g, "/"), sf);
-  }
-  for (const sf of originalFiles) {
-    for (const exportDecl of sf.getExportDeclarations()) {
-      const hasDefaultExport = exportDecl.getNamedExports().some(
-        (ne) => ne.getName() === "default"
-      );
-      if (!hasDefaultExport) continue;
-      const specifier = exportDecl.getModuleSpecifierValue();
-      if (!specifier) continue;
-      let defaultName;
-      try {
-        const resolved = exportDecl.getModuleSpecifierSourceFile();
-        if (resolved) {
-          defaultName = resolveDefaultExportName(resolved);
-        }
-      } catch {
-      }
-      if (!defaultName && specifier.startsWith("./")) {
-        const dir = sf.getFilePath().replace(/\\/g, "/");
-        const parentDir = dir.substring(0, dir.lastIndexOf("/"));
-        const candidatePath = resolve2(parentDir, stripJsExtension(specifier) + ".d.ts").replace(/\\/g, "/");
-        const target = fileMap.get(candidatePath);
-        if (target) {
-          defaultName = resolveDefaultExportName(target);
-        }
-      }
-      if (defaultName) {
-        publicApiNames.add(defaultName);
-      }
-    }
-  }
-}
-function resolveDefaultExportName(sourceFile) {
-  for (const exportAssign of sourceFile.getExportAssignments()) {
-    const expr = exportAssign.getExpression();
-    if (!expr) continue;
-    const name = expr.getText();
-    if (name) return name;
-  }
-  return void 0;
-}
-function extractPackageApi(typeFiles, packagePath, options) {
-  const limit = options?.limit ?? 50;
-  logger.debug(`Extraindo API do pacote: ${packagePath}`);
-  logger.debug(`Type files (${typeFiles.length}):`, typeFiles);
-  const jsFallback = typeFiles.length > 0 && typeFiles.every(
-    (f) => f.endsWith(".js") || f.endsWith(".mjs") || f.endsWith(".cjs")
-  );
-  if (jsFallback) {
-    logger.debug("Modo JS fallback ativado - incluindo todas as funcoes nomeadas");
-  }
-  const nodeModulesDir = findNodeModulesDir(packagePath);
-  const project = new Project({
-    skipAddingFilesFromTsConfig: true,
-    compilerOptions: {
-      allowJs: true,
-      checkJs: false,
-      declaration: true,
-      // Permite resolucao de types dentro do node_modules
-      moduleResolution: 100,
-      // Bundler
-      target: 2,
-      // ES2020
-      module: 200
-      // ESNext
-    }
-  });
-  try {
-    return extractPackageApiImpl(project, typeFiles, packagePath, limit, jsFallback, nodeModulesDir);
-  } finally {
-    project.getLanguageService().compilerObject.dispose();
-  }
-}
-function extractPackageApiImpl(project, typeFiles, packagePath, limit, jsFallback, nodeModulesDir) {
-  const visited = /* @__PURE__ */ new Set();
-  const sourceFiles = [];
-  for (const filePath of typeFiles) {
-    if (visited.size >= MAX_TOTAL_FILES) break;
-    if (visited.has(filePath)) continue;
-    visited.add(filePath);
-    try {
-      if (!existsSync2(filePath)) {
-        logger.debug(`Arquivo nao encontrado, ignorando: ${filePath}`);
-        continue;
-      }
-      const sourceFile = addSourceFile(project, filePath);
-      sourceFiles.push(sourceFile);
-    } catch (err) {
-      logger.debug(`Falha ao adicionar arquivo ${filePath}:`, err);
-    }
-  }
-  if (sourceFiles.length === 0) {
-    logger.debug("Nenhum source file adicionado ao projeto");
-    return { functions: [], types: [], constants: [], truncated: { functions: false, types: false, totalFunctions: 0, totalTypes: 0, shown: 0 } };
-  }
-  const originalFileCount = sourceFiles.length;
-  if (!jsFallback && nodeModulesDir) {
-    const reExportedFiles = followReExports(
-      project,
-      sourceFiles,
-      visited,
-      nodeModulesDir,
-      0
-    );
-    if (reExportedFiles.length > 0) {
-      sourceFiles.push(...reExportedFiles);
-      logger.debug(
-        `Seguiu ${reExportedFiles.length} re-exports (${visited.size} arquivos total)`
-      );
-    }
-  }
-  const originalFiles = sourceFiles.slice(0, originalFileCount);
-  const publicApiNames = /* @__PURE__ */ new Set();
-  for (const sf of originalFiles) {
-    const names = extractExports(sf);
-    for (const name of names) {
-      publicApiNames.add(name);
-    }
-  }
-  resolveDefaultReExportNames(originalFiles, sourceFiles, publicApiNames);
-  const allFunctions = [];
-  const allTypes = [];
-  const allConstants = [];
-  for (const sourceFile of sourceFiles) {
-    const functions = extractFunctions(sourceFile);
-    const types = extractTypes(sourceFile);
-    const exportNames = new Set(extractExports(sourceFile));
-    const sourceFilePath = sourceFile.getFilePath().replace(/\\/g, "/");
-    const pkgPathNormalized = packagePath.replace(/\\/g, "/");
-    let relativeSource;
-    if (sourceFilePath.startsWith(pkgPathNormalized)) {
-      relativeSource = sourceFilePath.slice(pkgPathNormalized.length).replace(/^\//, "");
-    } else {
-      const nmIdx = sourceFilePath.indexOf("node_modules/");
-      if (nmIdx !== -1) {
-        relativeSource = sourceFilePath.slice(nmIdx + "node_modules/".length);
-      } else {
-        relativeSource = sourceFilePath;
-      }
-    }
-    for (const fn of functions) {
-      if (fn.name.startsWith("_")) continue;
-      if (isLikelyMinified(fn.name)) continue;
-      if (fn.isExported || exportNames.has(fn.name) || publicApiNames.has(fn.name) || jsFallback) {
-        allFunctions.push({
-          ...fn,
-          sourceFile: relativeSource,
-          kind: classifySymbol("function", fn.name, fn.returnType)
-        });
-      }
-    }
-    for (const type of types) {
-      if (type.name.startsWith("_")) continue;
-      if (isLikelyMinified(type.name)) continue;
-      if (type.isExported || exportNames.has(type.name) || publicApiNames.has(type.name) || jsFallback) {
-        allTypes.push({ ...type, sourceFile: relativeSource });
-      }
-    }
-    const constants = extractConstants(sourceFile, jsFallback);
-    for (const constant of constants) {
-      if (constant.name.startsWith("_")) continue;
-      if (isLikelyMinified(constant.name)) continue;
-      if (constant.isExported || exportNames.has(constant.name) || publicApiNames.has(constant.name) || jsFallback) {
-        allConstants.push({ ...constant, sourceFile: relativeSource });
-      }
-    }
-  }
-  const uniqueFunctions = deduplicateByName(allFunctions);
-  const uniqueTypes = deduplicateByName(allTypes);
-  const uniqueConstants = deduplicateByName(allConstants);
-  const sortedFunctions = sortByRelevance(uniqueFunctions, publicApiNames);
-  const sortedTypes = sortByRelevance(uniqueTypes, publicApiNames);
-  const truncatedFunctions = uniqueFunctions.length > limit;
-  const truncatedTypes = uniqueTypes.length > limit;
-  return {
-    functions: sortedFunctions.slice(0, limit),
-    types: sortedTypes.slice(0, limit),
-    constants: uniqueConstants.slice(0, limit),
-    truncated: {
-      functions: truncatedFunctions,
-      types: truncatedTypes,
-      totalFunctions: uniqueFunctions.length,
-      totalTypes: uniqueTypes.length,
-      shown: limit
-    }
-  };
-}
-function extractConstants(sourceFile, includeAll = false) {
-  const constants = [];
-  for (const varStatement of sourceFile.getVariableStatements()) {
-    if (!varStatement.isExported() && !includeAll) continue;
-    for (const decl of varStatement.getDeclarations()) {
-      const init = decl.getInitializer();
-      if (init) {
-        const kind = init.getKind();
-        if (kind === 210 || kind === 208) continue;
-      }
-      const declType = decl.getType();
-      if (declType.getCallSignatures().length > 0) continue;
-      const name = decl.getName();
-      const type = expandMuiOverrideType(declType, simplifyType(declType.getText()));
-      constants.push({
-        name,
-        type,
-        isExported: true
-      });
-    }
-  }
-  return constants;
-}
-function isLikelyMinified(name) {
-  return name.length === 1;
-}
-function deduplicateByName(items) {
-  const seen = /* @__PURE__ */ new Map();
-  for (const item of items) {
-    const existing = seen.get(item.name);
-    if (!existing) {
-      seen.set(item.name, item);
-    } else if (symbolInfoScore(item) > symbolInfoScore(existing)) {
-      seen.set(item.name, item);
-    }
-  }
-  return [...seen.values()];
-}
-function symbolInfoScore(item) {
-  const record = item;
-  let score = 0;
-  if (typeof record.jsdoc === "string" && record.jsdoc.length > 0) score += 10;
-  if (Array.isArray(record.jsdocParams) && record.jsdocParams.length > 0) score += 5;
-  if (Array.isArray(record.params) && record.params.length > 0) score += 3;
-  if (typeof record.definition === "string" && record.definition.length > 10) score += 2;
-  return score;
-}
-function sortByRelevance(items, publicApiNames) {
-  return [...items].sort((a, b) => {
-    const aPublic = publicApiNames.has(a.name) ? 0 : 1;
-    const bPublic = publicApiNames.has(b.name) ? 0 : 1;
-    if (aPublic !== bPublic) return aPublic - bPublic;
-    const recordA = a;
-    const recordB = b;
-    const aJSDoc = typeof recordA.jsdoc === "string" && recordA.jsdoc.length > 0 ? 0 : 1;
-    const bJSDoc = typeof recordB.jsdoc === "string" && recordB.jsdoc.length > 0 ? 0 : 1;
-    if (aJSDoc !== bJSDoc) return aJSDoc - bJSDoc;
-    if (a.name.length !== b.name.length) return a.name.length - b.name.length;
-    return a.name.localeCompare(b.name);
-  });
-}
-
-// 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 normalizeKind(kind) {
-  if (kind === "interface" || kind === "enum") return "type";
-  return kind;
-}
-function normalizePath(p) {
-  return p.replace(/\\/g, "/");
-}
-function computeAvailableKinds(extracted, requestedKind) {
-  const kindCounts = /* @__PURE__ */ new Map();
-  for (const fn of extracted.functions) {
-    const kind = normalizeKind(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 = normalizeKind(classifySymbol("type", t.name));
-    if (isSemanticKindMatch(kind, requestedKind)) {
-      kindCounts.set(kind, (kindCounts.get(kind) ?? 0) + 1);
-    }
-  }
-  for (const c of extracted.constants) {
-    const kind = normalizeKind(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}`;
-  }
-  if (typeFiles.length === 0) {
-    return packageName;
-  }
-  return normalizePath(typeFiles[0]).replace(normalizedPkgPath, packageName);
-}
-var TYPE_FILES_COMPACT_THRESHOLD = 10;
-var TYPE_FILES_PREVIEW_COUNT = 5;
-function buildTypeFilesMeta(typeFiles, pkgPath) {
-  if (typeFiles.length <= TYPE_FILES_COMPACT_THRESHOLD) {
-    return {};
-  }
-  const normalizedPkgPath = normalizePath(pkgPath.endsWith("/") ? pkgPath : pkgPath + "/");
-  const subdirs = /* @__PURE__ */ new Set();
-  for (const tf of typeFiles) {
-    const normalized = normalizePath(tf);
-    const relative = normalized.replace(normalizedPkgPath, "").replace(/^\//, "");
-    const firstSegment = relative.split("/")[0];
-    if (firstSegment) {
-      subdirs.add(firstSegment);
-    }
-  }
-  const subdirCount = subdirs.size;
-  const summary = `${typeFiles.length} type files em ${subdirCount} subdiret\xF3rio${subdirCount === 1 ? "" : "s"}`;
-  const preview = typeFiles.slice(0, TYPE_FILES_PREVIEW_COUNT).map((tf) => {
-    const normalized = normalizePath(tf);
-    return normalized.replace(normalizedPkgPath, "").replace(/^\//, "") || tf;
-  });
-  return { summary, preview };
-}
-async function depsInfo(packageName, options = {}) {
-  const { cwd, format } = parseCommandOptions(options);
-  const ctx = options.ctx || "cli";
-  if (!packageName) {
-    throw new Error("Nome do pacote e obrigatorio. Exemplo: ai-tool deps info @mui/material");
-  }
-  try {
-    const result = readPackageJson(packageName, cwd);
-    if (result.version === "0.0.0" && !packageName.startsWith("@") && packageName.includes("/")) {
-      const basePkg = packageName.slice(0, packageName.indexOf("/"));
-      try {
-        const baseResult = readPackageJson(basePkg, cwd);
-        result.version = baseResult.version;
-        result.info.version = baseResult.version;
-      } catch {
-      }
-    }
-    const projectPkgPath = join3(cwd, "package.json");
-    if (existsSync3(projectPkgPath)) {
-      try {
-        const projectRaw = readFileSync3(projectPkgPath, "utf-8");
-        const projectPkg = JSON.parse(projectRaw);
-        const deps = projectPkg.dependencies ?? {};
-        const devDeps = projectPkg.devDependencies ?? {};
-        const declared = deps[packageName] ?? devDeps[packageName];
-        if (declared) {
-          result.declaredVersion = declared;
-        }
-      } catch {
-      }
-    }
-    if (!result.info.types && !result.info.typings) {
-      try {
-        resolvePackagePath(`@types/${packageName}`, cwd);
-        result.info.hasTypes = true;
-        result.info.typesSource = "@types";
-        result.info.typesPackage = `@types/${packageName}`;
-      } catch {
-      }
-    }
-    return formatOutput(result, format, (r) => formatDepsInfoText(r, ctx));
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (format === "json") {
-      return JSON.stringify({ error: message, package: packageName });
-    }
-    const lines = [
-      `Erro ao executar deps info: ${message}`,
-      "",
-      recoveryHint("package_not_found", ctx)
-    ];
-    return lines.join("\n");
-  }
-}
-async function depsApi(packageName, options = {}) {
-  const { cwd, format } = parseCommandOptions(options);
-  const ctx = options.ctx || "cli";
-  if (!packageName) {
-    throw new Error("Nome do pacote e obrigatorio. Exemplo: ai-tool deps api zustand");
-  }
-  try {
-    const pkgPath = resolvePackagePath(packageName, cwd);
-    let typeFiles;
-    let typesSource;
-    let typesPackage;
-    if (options.entry) {
-      const entryFile = resolveEntryPointFile(packageName, options.entry, cwd);
-      typeFiles = [entryFile];
-      typesSource = "builtin";
-    } else {
-      const resolved = resolveTypeFilesWithSource(packageName, cwd);
-      typeFiles = resolved.files;
-      typesSource = resolved.source;
-      typesPackage = resolved.typesPackage;
-    }
-    const effectiveLimit = options.kind ? Math.max((options.limit ?? 50) * 5, 200) : options.limit ?? 50;
-    const extracted = extractPackageApi(typeFiles, pkgPath, { limit: effectiveLimit });
-    let filteredFunctions = extracted.functions;
-    let filteredTypes = extracted.types;
-    let filteredConstants = extracted.constants;
-    if (options.kind) {
-      const kind = options.kind;
-      filteredFunctions = extracted.functions.filter((fn) => classifySymbol("function", fn.name, fn.returnType) === kind);
-      filteredTypes = extracted.types.filter((t) => {
-        const resolvedKind = classifySymbol("type", t.name) === "hook" ? "hook" : t.kind;
-        return resolvedKind === kind;
-      });
-      filteredConstants = extracted.constants.filter(() => kind === "const");
-      const realLimit = options.limit ?? 50;
-      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(),
-      package: packageName,
-      resolvedPath: pkgPath,
-      typeFiles,
-      functions: filteredFunctions,
-      types: filteredTypes,
-      constants: filteredConstants.length > 0 ? filteredConstants : void 0,
-      truncated: options.kind ? {
-        functions: filteredFunctions.length >= (options.limit ?? 50),
-        types: filteredTypes.length >= (options.limit ?? 50),
-        totalFunctions: filteredFunctions.length,
-        totalTypes: filteredTypes.length,
-        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,
-      typesSource,
-      typesPackage
-    };
-    return formatOutput(result, format, (r) => formatDepsApiText(r, ctx));
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (message.includes("nao possui TypeScript declarations")) {
-      if (format === "json") {
-        return JSON.stringify({ error: message, package: packageName });
-      }
-      const lines = [
-        `${packageName} - Sem TypeScript declarations`,
-        ``,
-        `Este pacote nao possui tipos TypeScript embutidos.`,
-        ``,
-        `Opcoes:`,
-        `  1. Instale os tipos separados: <package_manager> install -D @types/${packageName}`,
-        `  2. ${hint("deps_info", ctx, { "<pacote>": packageName })} - ver metadados do pacote`
-      ];
-      return lines.join("\n");
-    }
-    throw new Error(`Erro ao executar deps api: ${message}`);
-  }
-}
-var DEFAULT_SEARCH_LIMIT = 15;
-var MAX_SEARCH_LIMIT = 200;
-var AUXILIARY_TYPE_SUFFIXES = [
-  "Props",
-  "PropsWithRef",
-  "Overrides",
-  "ClassKey",
-  "DefaultComponent",
-  "TypeMap",
-  "Options",
-  "Config",
-  "Settings",
-  "Fn",
-  "Token",
-  "Locale",
-  "Width",
-  "Part"
-];
-function hasWildcard(query) {
-  return query.includes("*");
-}
-function matchWithWildcard(name, query) {
-  if (!query.includes("*")) {
-    return name.toLowerCase() === query.toLowerCase();
-  }
-  const q = query.toLowerCase();
-  const n = name.toLowerCase();
-  if (q.startsWith("*") && q.endsWith("*") && q.length >= 2) {
-    const inner = q.slice(1, -1);
-    return inner.length > 0 && n.includes(inner);
-  }
-  if (q.endsWith("*") && !q.startsWith("*")) {
-    const prefix = q.slice(0, -1);
-    return prefix.length > 0 && n.startsWith(prefix);
-  }
-  if (q.startsWith("*") && !q.endsWith("*")) {
-    const suffix = q.slice(1);
-    return suffix.length > 0 && n.endsWith(suffix);
-  }
-  return n.includes(q.replace(/\*/g, ""));
-}
-function calculateWildcardMatchScore(name, query, kind, isExported) {
-  let score = 0;
-  const n = name.toLowerCase();
-  const q = query.toLowerCase();
-  if (q.endsWith("*") && !q.startsWith("*")) {
-    const prefix = q.slice(0, -1);
-    if (n === prefix) {
-      score += 100;
-    } else if (n.startsWith(prefix)) {
-      score += 80;
-    }
-  } else if (q.startsWith("*") && !q.endsWith("*")) {
-    const suffix = q.slice(1);
-    if (n === suffix) {
-      score += 100;
-    } else if (n.endsWith(suffix)) {
-      score += 80;
-    }
-  } else if (q.startsWith("*") && q.endsWith("*") && q.length >= 2) {
-    const inner = q.slice(1, -1);
-    if (n === inner) {
-      score += 100;
-    } else if (n.includes(inner)) {
-      score += 50;
-    }
-  } else {
-    if (n.includes(q.replace(/\*/g, ""))) {
-      score += 50;
-    }
-  }
-  if (kind === "function" || kind === "component" || kind === "hook") {
-    score += 15;
-  }
-  if (isExported) {
-    score += 10;
-  }
-  for (const suffix of AUXILIARY_TYPE_SUFFIXES) {
-    if (name.endsWith(suffix)) {
-      score -= 20;
-      break;
-    }
-  }
-  return score;
-}
-function calculateMatchScore(name, queryLower, kind, isExported) {
-  const nameLower = name.toLowerCase();
-  let score = 0;
-  if (nameLower === queryLower) {
-    score += 100;
-  } else if (nameLower.startsWith(queryLower)) {
-    score += 80;
-  } else {
-    score += 50;
-  }
-  if (nameLower.length <= queryLower.length + 5) {
-    score += 10;
-  }
-  if (kind === "function" || kind === "component" || kind === "hook") {
-    score += 15;
-  }
-  if (isExported) {
-    score += 10;
-  }
-  for (const suffix of AUXILIARY_TYPE_SUFFIXES) {
-    if (name.endsWith(suffix)) {
-      score -= 20;
-      break;
-    }
-  }
-  return score;
-}
-async function depsSearch(packageName, query, options = {}) {
-  const { cwd, format } = parseCommandOptions(options);
-  const ctx = options.ctx || "cli";
-  if (!packageName) {
-    throw new Error(
-      "Nome do pacote e obrigatorio. Exemplo: ai-tool deps search @mui/material Button"
-    );
-  }
-  if (!query) {
-    throw new Error(
-      "Termo de busca e obrigatorio. Exemplo: ai-tool deps search zustand create"
-    );
-  }
-  try {
-    const pkgPath = resolvePackagePath(packageName, cwd);
-    const resolved = resolveTypeFilesWithSource(packageName, cwd);
-    const typeFiles = resolved.files;
-    const extracted = extractPackageApi(typeFiles, pkgPath, { limit: 200 });
-    const jsFallback = typeFiles.length > 0 && typeFiles.every(
-      (f) => f.endsWith(".js") || f.endsWith(".mjs") || f.endsWith(".cjs")
-    );
-    const queryLower = query.toLowerCase();
-    const scored = [];
-    const filesSet = /* @__PURE__ */ new Set();
-    const normalizedPkgPath = normalizePath(pkgPath);
-    const useWildcard = hasWildcard(query);
-    const matchFn = useWildcard ? (name) => matchWithWildcard(name, query) || matchWithWildcard(stripModulePrefix(name), query) : (name) => {
-      const n = 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 = 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 = 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}`;
-        const file = relativeTypeFile(typeFiles, normalizedPkgPath, packageName, fn.sourceFile);
-        scored.push({ name: fn.name, kind, file, signature, _score: score });
-        filesSet.add(file);
-      }
-    }
-    for (const t of extracted.types) {
-      if (matchFn(t.name)) {
-        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 });
-        filesSet.add(file);
-      }
-    }
-    for (const c of extracted.constants) {
-      if (matchFn(c.name)) {
-        const score = scoreFn(c.name, "const", c.isExported);
-        const file = relativeTypeFile(typeFiles, normalizedPkgPath, packageName, c.sourceFile);
-        scored.push({ name: c.name, kind: "const", file, signature: c.type, _score: score });
-        filesSet.add(file);
-      }
-    }
-    if (!useWildcard && scored.length > 0) {
-      const exactKinds = new Set(scored.map((m) => m.kind));
-      const matchedNames = new Set(scored.map((m) => m.name));
-      for (const fn of extracted.functions) {
-        if (matchedNames.has(fn.name)) continue;
-        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);
-        if (score < 90) continue;
-        const params = fn.params.map((p) => `${p.name}: ${p.type}`).join(", ");
-        const signature = `${fn.name}(${params}): ${fn.returnType}`;
-        const file = relativeTypeFile(typeFiles, normalizedPkgPath, packageName, fn.sourceFile);
-        scored.push({ name: fn.name, kind, file, signature, _score: score });
-        filesSet.add(file);
-        matchedNames.add(fn.name);
-      }
-      for (const t of extracted.types) {
-        if (matchedNames.has(t.name)) continue;
-        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);
-        if (score < 90) continue;
-        const file = relativeTypeFile(typeFiles, normalizedPkgPath, packageName, t.sourceFile);
-        scored.push({ name: t.name, kind, file, signature: t.definition, _score: score });
-        filesSet.add(file);
-        matchedNames.add(t.name);
-      }
-      for (const c of extracted.constants) {
-        if (matchedNames.has(c.name)) continue;
-        if (exactKinds.has("const")) continue;
-        if (!fuzzyMatchFn(c.name)) continue;
-        const score = scoreFn(c.name, "const", c.isExported);
-        if (score < 90) continue;
-        const file = relativeTypeFile(typeFiles, normalizedPkgPath, packageName, c.sourceFile);
-        scored.push({ name: c.name, kind: "const", file, signature: c.type, _score: score });
-        filesSet.add(file);
-        matchedNames.add(c.name);
-      }
-    }
-    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 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: allMatches,
-      summary: {
-        total: scored.length,
-        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
-    };
-    return formatOutput(result, format, (r) => formatDepsSearchText(r, ctx));
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    if (message.includes("nao encontrado") || message.includes("not found") || message.includes("Cannot find")) {
-      if (format === "json") {
-        return JSON.stringify({ error: message, package: packageName, query });
-      }
-      const lines = [
-        `Erro ao executar deps search: ${message}`,
-        "",
-        recoveryHint("package_not_found", ctx)
-      ];
-      return lines.join("\n");
-    }
-    throw new Error(`Erro ao executar deps search: ${message}`);
-  }
-}
-
-export {
-  describe,
-  depsInfo,
-  depsApi,
-  depsSearch
-};