@justmpm/ai-tool 0.6.1 → 0.7.1

package/dist/{chunk-XHYBVOXY.js → chunk-SVY7A47I.js}

@@ -47,6 +47,16 @@ function detectCategory(filePath) {
   if (fileName.endsWith(".astro") && normalized.includes("/layouts/")) {
     return "layout";
   }
+  if (normalized.includes("functions/src/") && !normalized.includes("/__tests__/")) {
+    if (!fileName.includes("index") && !normalized.includes("/types/")) {
+      return "cloud-function";
+    }
+  }
+  if (normalized.includes("/triggers/") || normalized.includes("/callable/") || normalized.includes("/scheduled/")) {
+    if (normalized.includes("functions/") || normalized.includes("firebase/")) {
+      return "cloud-function";
+    }
+  }
   if (normalized.includes("/api/") || normalized.includes("/server/") || fileNameNoExt.endsWith(".server") || fileNameNoExt === "+server") {
     return "route";
   }
@@ -106,6 +116,7 @@ var categoryIcons = {
   type: "\u{1F4DD}",
   config: "\u2699\uFE0F",
   test: "\u{1F9EA}",
+  "cloud-function": "\u26A1",
   other: "\u{1F4C1}"
 };
 function isEntryPoint(filePath) {
@@ -149,6 +160,7 @@ function formatMapSummary(result, areasInfo) {
     "layout",
     "route",
     "store",
+    "cloud-function",
     "other"
   ];
   const catParts = [];
@@ -167,6 +179,16 @@ function formatMapSummary(result, areasInfo) {
   }
   out += `
 `;
+  const cloudFunctionCount = result.summary.categories["cloud-function"] || 0;
+  if (cloudFunctionCount > 0) {
+    out += `\u{1F525} Firebase Cloud Functions detectado
+`;
+    out += `   ${cloudFunctionCount} function(s) em functions/src/
+`;
+    out += `   \u2192 Use 'ai-tool functions' para listar triggers
+
+`;
+  }
   if (result.circularDependencies.length > 0) {
     out += `\u26A0\uFE0F ${result.circularDependencies.length} depend\xEAncia(s) circular(es) detectada(s)
 `;
@@ -225,13 +247,14 @@ function formatMapText(result) {
     "type",
     "config",
     "test",
+    "cloud-function",
     "other"
   ];
   for (const cat of catOrder) {
     const count = result.summary.categories[cat];
     if (count) {
       const icon = categoryIcons[cat];
-      out += `   ${icon} ${cat.padEnd(12)} ${count}
+      out += `   ${icon} ${cat.padEnd(14)} ${count}
 `;
     }
   }
@@ -356,12 +379,93 @@ function formatDeadText(result) {
     out += `
 `;
   }
-  out += `\u{1F4A1} SUGEST\xC3O
+  out += `\u{1F4A1} COMO RESOLVER
+
+`;
+  out += `   1. Falsos positivos? Adicione ao .analyze/areas.config.json:
+`;
+  out += `      { "ignore": ["functions/lib/**", "**/*.test.ts"] }
+
+`;
+  out += `   2. Remover automaticamente:
+`;
+  out += `      npx knip --fix
+
+`;
+  out += `   3. Ver detalhes em JSON:
+`;
+  out += `      ai-tool dead --format=json
+`;
+  const suggestions = generateIgnoreSuggestions(result);
+  if (suggestions.length > 0) {
+    out += `
+\u{1F3AF} SUGEST\xD5ES INTELIGENTES
+
 `;
-  out += `   Execute 'npx knip --fix' para remover automaticamente.
+    for (const suggestion of suggestions) {
+      out += `   ${suggestion.icon} ${suggestion.pattern}
 `;
+      out += `      Motivo: ${suggestion.reason}
+`;
+      out += `      Arquivos afetados: ${suggestion.count}
+
+`;
+    }
+  }
   return out;
 }
+function generateIgnoreSuggestions(result) {
+  const suggestions = [];
+  const files = result.files.map((f) => f.path);
+  const libFiles = files.filter((f) => f.includes("functions/lib/"));
+  if (libFiles.length > 0) {
+    suggestions.push({
+      icon: "\u{1F4E6}",
+      pattern: "functions/lib/**",
+      reason: "Build compilado do Firebase Functions",
+      count: libFiles.length
+    });
+  }
+  const testFiles = files.filter((f) => /\.(test|spec)\.(ts|tsx|js|jsx)$/.test(f));
+  if (testFiles.length > 3) {
+    suggestions.push({
+      icon: "\u{1F9EA}",
+      pattern: "**/*.(test|spec).(ts|tsx|js|jsx)",
+      reason: "Arquivos de teste geralmente s\xE3o entry points pr\xF3prios",
+      count: testFiles.length
+    });
+  }
+  const configFiles = files.filter(
+    (f) => f.includes("vite.config") || f.includes("next.config") || f.includes("tailwind.config") || f.includes("jest.config") || f.includes("eslint.config")
+  );
+  if (configFiles.length > 0) {
+    suggestions.push({
+      icon: "\u2699\uFE0F",
+      pattern: "**/*.config.(ts|js|mjs|cjs)",
+      reason: "Arquivos de configura\xE7\xE3o s\xE3o entry points",
+      count: configFiles.length
+    });
+  }
+  const dtsFiles = files.filter((f) => f.endsWith(".d.ts"));
+  if (dtsFiles.length > 0) {
+    suggestions.push({
+      icon: "\u{1F4D8}",
+      pattern: "**/*.d.ts",
+      reason: "Arquivos de defini\xE7\xE3o TypeScript",
+      count: dtsFiles.length
+    });
+  }
+  const scriptFiles = files.filter((f) => f.startsWith("scripts/") || f.includes("/scripts/"));
+  if (scriptFiles.length > 0) {
+    suggestions.push({
+      icon: "\u{1F4DC}",
+      pattern: "scripts/**",
+      reason: "Scripts de automa\xE7\xE3o s\xE3o entry points",
+      count: scriptFiles.length
+    });
+  }
+  return suggestions;
+}
 function formatImpactText(result) {
   let out = "";
   out += `
@@ -799,6 +903,7 @@ function formatAreaDetailText(result, options = {}) {
     "type",
     "config",
     "test",
+    "cloud-function",
     "other"
   ];
   const catParts = [];
@@ -869,20 +974,32 @@ function formatFindText(result) {
   out += `\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
 
 `;
-  out += `\u{1F50D} "${result.query}"`;
-  if (result.filters.type) {
-    out += ` [type: ${result.filters.type}]`;
-  }
-  if (result.filters.area) {
-    out += ` [area: ${result.filters.area}]`;
+  if (result.query) {
+    out += `\u{1F50D} "${result.query}"`;
+    if (result.filters.type) {
+      out += ` [type: ${result.filters.type}]`;
+    }
+    if (result.filters.area) {
+      out += ` [area: ${result.filters.area}]`;
+    }
+    out += `
+
+`;
+  } else {
+    out += `\u{1F4CB} Listando todos os s\xEDmbolos do tipo: ${result.filters.type || "all"}
+
+`;
   }
-  out += `
+  if (!result.definition && result.references.length === 0 && result.summary.definitions === 0) {
+    if (result.query) {
+      out += `\u274C Nenhum resultado encontrado para "${result.query}"
 
 `;
-  if (!result.definition && result.references.length === 0) {
-    out += `\u274C Nenhum resultado encontrado para "${result.query}"
+    } else {
+      out += `\u274C Nenhum s\xEDmbolo do tipo "${result.filters.type}" encontrado
 
 `;
+    }
     out += `\u{1F4A1} Dicas:
 `;
     out += `   \u2022 Verifique a ortografia
@@ -1057,6 +1174,26 @@ function formatAreaContextText(result) {
 `;
       out += `      state: ${st.state}
 
+`;
+    }
+  }
+  if (result.triggers && result.triggers.length > 0) {
+    out += `\u26A1 TRIGGERS (${result.triggers.length})
+
+`;
+    for (const t of result.triggers) {
+      const filePart = t.file.split("/").pop() || t.file;
+      out += `   ${t.name}`.padEnd(35) + `${t.triggerType.padEnd(25)}[${filePart}:${t.line}]
+`;
+      if (t.triggerPath) {
+        out += `      path: ${t.triggerPath}
+`;
+      }
+      if (t.triggerSchedule) {
+        out += `      schedule: ${t.triggerSchedule}
+`;
+      }
+      out += `
 `;
     }
   }
@@ -1077,6 +1214,10 @@ function formatAreaContextText(result) {
 `;
   out += `   Stores: ${result.stores.length}
 `;
+  if (result.triggers && result.triggers.length > 0) {
+    out += `   Triggers: ${result.triggers.length}
+`;
+  }
   return out;
 }
 
@@ -1559,9 +1700,17 @@ var FOLDER_PATTERNS = [
   { pattern: /store\/.*[Aa]uth/, area: "auth", priority: 70 },
   { pattern: /store\/.*[Uu]ser/, area: "user", priority: 70 },
   // ============================================================================
-  // CLOUD FUNCTIONS
+  // FIREBASE CLOUD FUNCTIONS (expandido)
   // ============================================================================
   { pattern: /functions\/src\//, area: "cloud-functions", priority: 80 },
+  { pattern: /functions\/src\/triggers\//, area: "triggers", priority: 95 },
+  { pattern: /functions\/src\/callable\//, area: "callable", priority: 95 },
+  { pattern: /functions\/src\/scheduled\//, area: "scheduled", priority: 95 },
+  { pattern: /functions\/src\/firestore\//, area: "firestore-triggers", priority: 95 },
+  { pattern: /functions\/src\/auth\//, area: "auth-triggers", priority: 95 },
+  { pattern: /functions\/src\/storage\//, area: "storage-triggers", priority: 95 },
+  { pattern: /functions\/src\/pubsub\//, area: "pubsub", priority: 95 },
+  { pattern: /functions\/src\/https\//, area: "callable", priority: 95 },
   // ============================================================================
   // OUTROS
   // ============================================================================
@@ -1611,7 +1760,17 @@ var KEYWORD_PATTERNS = [
   { keyword: /[Mm]anifest/, area: "pwa", priority: 55 },
   // PDF (genérico)
   { keyword: /[Pp]df[Ee]xport/, area: "export", priority: 60 },
-  { keyword: /[Dd]ocx[Ee]xport/, area: "export", priority: 60 }
+  { keyword: /[Dd]ocx[Ee]xport/, area: "export", priority: 60 },
+  // Firebase Cloud Functions triggers
+  { keyword: /[Oo]nCall/, area: "callable", priority: 70 },
+  { keyword: /[Oo]nRequest/, area: "callable", priority: 70 },
+  { keyword: /[Oo]nSchedule/, area: "scheduled", priority: 70 },
+  { keyword: /[Oo]n[A-Z].*Created/, area: "triggers", priority: 70 },
+  { keyword: /[Oo]n[A-Z].*Updated/, area: "triggers", priority: 70 },
+  { keyword: /[Oo]n[A-Z].*Deleted/, area: "triggers", priority: 70 },
+  { keyword: /[Oo]n[A-Z].*Written/, area: "triggers", priority: 70 },
+  { keyword: /[Oo]nObject/, area: "storage-triggers", priority: 70 },
+  { keyword: /[Oo]nMessage/, area: "pubsub", priority: 70 }
 ];
 var AREA_NAMES = {
   // Autenticação e usuário
@@ -1658,6 +1817,13 @@ var AREA_NAMES = {
   layout: "Layout",
   "shared-ui": "UI Compartilhada",
   "cloud-functions": "Cloud Functions",
+  triggers: "Triggers Firebase",
+  callable: "Callable Functions",
+  scheduled: "Scheduled Functions",
+  "firestore-triggers": "Firestore Triggers",
+  "auth-triggers": "Auth Triggers",
+  "storage-triggers": "Storage Triggers",
+  pubsub: "Pub/Sub",
   assets: "Assets",
   scripts: "Scripts",
   // UI patterns
@@ -1711,7 +1877,14 @@ var AREA_DESCRIPTIONS = {
   core: "Providers e configura\xE7\xE3o principal",
   layout: "Layout e navega\xE7\xE3o",
   "shared-ui": "Componentes de UI compartilhados",
-  "cloud-functions": "Cloud Functions (serverless)",
+  "cloud-functions": "Firebase Cloud Functions (serverless)",
+  triggers: "Event-driven Firebase triggers",
+  callable: "HTTPS callable functions (frontend SDK)",
+  scheduled: "Scheduled/cron functions",
+  "firestore-triggers": "Triggers para eventos do Firestore",
+  "auth-triggers": "Triggers para eventos de autentica\xE7\xE3o",
+  "storage-triggers": "Triggers para eventos do Storage",
+  pubsub: "Triggers para mensagens Pub/Sub",
   assets: "Assets p\xFAblicos",
   scripts: "Scripts de automa\xE7\xE3o",
   // UI patterns
@@ -2748,6 +2921,12 @@ function collectSuggestions(targetPath, graph, allFiles, limit) {
       priority: "low"
     });
   }
+  const cloudFunctionSuggestions = suggestFirebaseRules(targetPath, allFiles);
+  for (const suggestion of cloudFunctionSuggestions) {
+    if (addedPaths.has(suggestion.path)) continue;
+    addedPaths.add(suggestion.path);
+    suggestions.push(suggestion);
+  }
   const priorityOrder = {
     critical: 0,
     high: 1,
@@ -2806,6 +2985,63 @@ function findTargetFile2(target, allFiles) {
   }
   return null;
 }
+function suggestFirebaseRules(targetPath, allFiles) {
+  const suggestions = [];
+  if (!targetPath.includes("functions/src/")) {
+    return suggestions;
+  }
+  const isFirestoreTrigger = targetPath.toLowerCase().includes("firestore") || targetPath.toLowerCase().includes("document");
+  const isStorageTrigger = targetPath.toLowerCase().includes("storage");
+  for (const file of allFiles) {
+    const fileName = file.split("/").pop()?.toLowerCase() || "";
+    if (fileName === "firestore.rules" || file.endsWith("firestore.rules")) {
+      if (isFirestoreTrigger) {
+        suggestions.push({
+          path: file,
+          category: "config",
+          reason: "Regras Firestore (trigger relacionado)",
+          priority: "high"
+        });
+      } else {
+        suggestions.push({
+          path: file,
+          category: "config",
+          reason: "Regras Firestore (Cloud Function)",
+          priority: "medium"
+        });
+      }
+    }
+    if (fileName === "storage.rules" || file.endsWith("storage.rules")) {
+      if (isStorageTrigger) {
+        suggestions.push({
+          path: file,
+          category: "config",
+          reason: "Regras Storage (trigger relacionado)",
+          priority: "high"
+        });
+      } else {
+        suggestions.push({
+          path: file,
+          category: "config",
+          reason: "Regras Storage (Cloud Function)",
+          priority: "low"
+        });
+      }
+    }
+  }
+  if (!targetPath.endsWith("index.ts")) {
+    const indexFile = allFiles.find((f) => f.includes("functions/src/index"));
+    if (indexFile) {
+      suggestions.push({
+        path: indexFile,
+        category: "config",
+        reason: "Exports de Cloud Functions",
+        priority: "high"
+      });
+    }
+  }
+  return suggestions;
+}
 function formatNotFound2(target, allFiles) {
   return formatFileNotFound({ target, allFiles, command: "suggest" });
 }
@@ -2881,11 +3117,11 @@ function simplifyType(typeText) {
   return simplified;
 }
 function extractFunctions(sourceFile) {
-  const functions = [];
+  const functions2 = [];
   for (const func of sourceFile.getFunctions()) {
     const name = func.getName();
     if (!name) continue;
-    functions.push({
+    functions2.push({
       name,
       params: extractParams(func.getParameters()),
       returnType: simplifyType(func.getReturnType().getText()),
@@ -2903,7 +3139,7 @@ function extractFunctions(sourceFile) {
       if (init.getKind() === SyntaxKind.ArrowFunction) {
         const arrowFunc = init.asKind(SyntaxKind.ArrowFunction);
         if (!arrowFunc) continue;
-        functions.push({
+        functions2.push({
           name: varDecl.getName(),
           params: extractParams(arrowFunc.getParameters()),
           returnType: simplifyType(arrowFunc.getReturnType().getText()),
@@ -2916,7 +3152,7 @@ function extractFunctions(sourceFile) {
       if (init.getKind() === SyntaxKind.FunctionExpression) {
         const funcExpr = init.asKind(SyntaxKind.FunctionExpression);
         if (!funcExpr) continue;
-        functions.push({
+        functions2.push({
           name: varDecl.getName(),
           params: extractParams(funcExpr.getParameters()),
           returnType: simplifyType(funcExpr.getReturnType().getText()),
@@ -2928,7 +3164,7 @@ function extractFunctions(sourceFile) {
       }
     }
   }
-  return functions;
+  return functions2;
 }
 function extractTypes(sourceFile) {
   const types = [];
@@ -3023,6 +3259,12 @@ import { readdirSync as readdirSync2, statSync as statSync2 } from "fs";
 import { join as join4, extname as extname2, resolve } from "path";
 import { Project as Project2, SyntaxKind as SyntaxKind2 } from "ts-morph";
 var CODE_EXTENSIONS2 = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs"]);
+var DEBUG = process.env.DEBUG_ANALYZE === "true";
+function debugLog(...args) {
+  if (DEBUG) {
+    console.error("[analyze:debug]", ...args);
+  }
+}
 var IGNORED_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
   "dist",
@@ -3035,8 +3277,69 @@ var IGNORED_DIRS = /* @__PURE__ */ new Set([
   ".vercel",
   ".analyze"
 ]);
+var FIREBASE_V2_TRIGGERS = /* @__PURE__ */ new Set([
+  // HTTPS (firebase-functions/v2/https)
+  "onCall",
+  "onRequest",
+  // Firestore (firebase-functions/v2/firestore)
+  "onDocumentCreated",
+  "onDocumentCreatedWithAuthContext",
+  "onDocumentUpdated",
+  "onDocumentUpdatedWithAuthContext",
+  "onDocumentDeleted",
+  "onDocumentDeletedWithAuthContext",
+  "onDocumentWritten",
+  "onDocumentWrittenWithAuthContext",
+  // Realtime Database (firebase-functions/v2/database)
+  "onValueCreated",
+  "onValueUpdated",
+  "onValueDeleted",
+  "onValueWritten",
+  // Scheduler (firebase-functions/v2/scheduler)
+  "onSchedule",
+  // Storage (firebase-functions/v2/storage)
+  "onObjectFinalized",
+  "onObjectArchived",
+  "onObjectDeleted",
+  "onMetadataUpdated",
+  // Pub/Sub (firebase-functions/v2/pubsub)
+  "onMessagePublished",
+  // Identity (firebase-functions/v2/identity)
+  "beforeUserCreated",
+  "beforeUserSignedIn",
+  "beforeEmailSent",
+  "beforeSmsSent",
+  // Alerts - Crashlytics (firebase-functions/v2/alerts/crashlytics)
+  "onNewFatalIssuePublished",
+  "onNewNonfatalIssuePublished",
+  "onNewAnrIssuePublished",
+  "onRegressionAlertPublished",
+  "onStabilityDigestPublished",
+  "onVelocityAlertPublished",
+  // Alerts - App Distribution (firebase-functions/v2/alerts/appDistribution)
+  "onNewTesterIosDevicePublished",
+  "onInAppFeedbackPublished",
+  // Alerts - Performance (firebase-functions/v2/alerts/performance)
+  "onThresholdAlertPublished",
+  // Alerts - Billing (firebase-functions/v2/alerts/billing)
+  "onPlanUpdatePublished",
+  "onPlanAutomatedUpdatePublished",
+  // Remote Config (firebase-functions/v2/remoteConfig)
+  "onConfigUpdated",
+  // Eventarc (firebase-functions/v2/eventarc)
+  "onCustomEventPublished",
+  // Tasks (firebase-functions/v2/tasks)
+  "onTaskDispatched",
+  // Test Lab (firebase-functions/v2/testLab)
+  "onTestMatrixCompleted"
+]);
 function indexProject(cwd) {
   const allFiles = getAllCodeFiles(cwd);
+  debugLog(`Indexando ${allFiles.length} arquivos em ${cwd}`);
+  const functionFiles = allFiles.filter((f) => f.includes("functions/src/"));
+  if (functionFiles.length > 0) {
+    debugLog(`Encontrados ${functionFiles.length} arquivos em functions/src/:`, functionFiles);
+  }
   const project = createProject2(cwd);
   for (const file of allFiles) {
     try {
@@ -3136,6 +3439,55 @@ function indexProject(cwd) {
           if (isExported) {
             exports.push(name);
           }
+        } else if (initKind === SyntaxKind2.CallExpression) {
+          const triggerName = extractFirebaseTriggerName(init);
+          if (DEBUG && filePath.includes("functions/src/")) {
+            const initText = init.getText().slice(0, 50);
+            debugLog(`[CF] Analisando: ${name} = ${initText}...`);
+            if (triggerName) {
+              debugLog(`[CF] \u2713 Trigger detectado: ${triggerName}`);
+            }
+          }
+          if (triggerName && FIREBASE_V2_TRIGGERS.has(triggerName)) {
+            const triggerInfo = extractTriggerInfo(init, triggerName);
+            const symbol = {
+              name,
+              file: filePath,
+              line: varDecl.getStartLineNumber(),
+              kind: "trigger",
+              signature: `${isExported ? "export " : ""}const ${name} = ${triggerName}(...)`,
+              isExported,
+              triggerInfo
+            };
+            symbols.push(symbol);
+            if (!symbolsByName[name]) {
+              symbolsByName[name] = [];
+            }
+            symbolsByName[name].push(symbol);
+            if (isExported) {
+              exports.push(name);
+            }
+          } else {
+            const declKind = varStatement.getDeclarationKind();
+            if (declKind.toString() === "const") {
+              const symbol = {
+                name,
+                file: filePath,
+                line: varDecl.getStartLineNumber(),
+                kind: "const",
+                signature: `${isExported ? "export " : ""}const ${name} = ${truncateCode(init.getText(), 40)}`,
+                isExported
+              };
+              symbols.push(symbol);
+              if (!symbolsByName[name]) {
+                symbolsByName[name] = [];
+              }
+              symbolsByName[name].push(symbol);
+              if (isExported) {
+                exports.push(name);
+              }
+            }
+          }
         } else {
           const declKind = varStatement.getDeclarationKind();
           if (declKind.toString() !== "const") continue;
@@ -3290,6 +3642,44 @@ function inferSymbolKind(name, context2) {
   }
   return context2 === "function" ? "function" : "const";
 }
+function extractFirebaseTriggerName(init) {
+  const text = init.getText();
+  for (const trigger of FIREBASE_V2_TRIGGERS) {
+    const pattern = new RegExp(`(?:^|\\.|\\s)${trigger}(?:<[^>]*>)?\\s*\\(`);
+    if (pattern.test(text)) {
+      return trigger;
+    }
+  }
+  return null;
+}
+function extractTriggerInfo(init, triggerName) {
+  const text = init.getText();
+  const info = { triggerType: triggerName };
+  if (triggerName.startsWith("onDocument") || triggerName.startsWith("onValue")) {
+    const pathMatch = text.match(/\(\s*["'`]([^"'`]+)["'`]/);
+    if (pathMatch) {
+      info.triggerPath = pathMatch[1];
+    }
+  }
+  if (triggerName === "onSchedule") {
+    const scheduleMatch = text.match(/onSchedule\s*\(\s*["'`]([^"'`]+)["'`]/);
+    if (scheduleMatch) {
+      info.triggerSchedule = scheduleMatch[1];
+    } else {
+      const objectScheduleMatch = text.match(/schedule\s*:\s*["'`]([^"'`]+)["'`]/);
+      if (objectScheduleMatch) {
+        info.triggerSchedule = objectScheduleMatch[1];
+      }
+    }
+  }
+  if (triggerName.startsWith("onObject") || triggerName === "onMetadataUpdated") {
+    const bucketMatch = text.match(/bucket\s*:\s*["'`]([^"'`]+)["'`]/);
+    if (bucketMatch) {
+      info.triggerPath = bucketMatch[1];
+    }
+  }
+  return info;
+}
 function simplifyType2(typeText) {
   if (!typeText) return "unknown";
   let simplified = typeText.replace(/import\([^)]+\)\./g, "");
@@ -3354,7 +3744,7 @@ async function context(target, options = {}) {
     const absolutePath = resolve2(cwd, targetPath);
     const sourceFile = addSourceFile(project, absolutePath);
     const imports = extractImports(sourceFile);
-    const functions = extractFunctions(sourceFile);
+    const functions2 = extractFunctions(sourceFile);
     const types = extractTypes(sourceFile);
     const exports = extractExports(sourceFile);
     const result = {
@@ -3364,7 +3754,7 @@ async function context(target, options = {}) {
       category: detectCategory(targetPath),
       imports,
       exports,
-      functions,
+      functions: functions2,
       types
     };
     if (format === "json") {
@@ -3497,10 +3887,11 @@ async function areaContext(areaName, options = {}) {
     }
     const types = [];
     const hooks = [];
-    const functions = [];
+    const functions2 = [];
     const components = [];
     const services = [];
     const stores = [];
+    const triggers = [];
     for (const filePath of areaFiles) {
       const fileData = index.files[filePath];
       if (!fileData) continue;
@@ -3545,7 +3936,7 @@ async function areaContext(areaName, options = {}) {
                 returns: symbol.returnType || "unknown"
               });
             } else {
-              functions.push({
+              functions2.push({
                 name: symbol.name,
                 file: filePath,
                 line: symbol.line,
@@ -3564,6 +3955,16 @@ async function areaContext(areaName, options = {}) {
               });
             }
             break;
+          case "trigger":
+            triggers.push({
+              name: symbol.name,
+              file: filePath,
+              line: symbol.line,
+              triggerType: symbol.triggerInfo?.triggerType || "unknown",
+              triggerPath: symbol.triggerInfo?.triggerPath,
+              triggerSchedule: symbol.triggerInfo?.triggerSchedule
+            });
+            break;
         }
       }
     }
@@ -3579,10 +3980,11 @@ async function areaContext(areaName, options = {}) {
       },
       types,
       hooks,
-      functions,
+      functions: functions2,
       components,
       services,
-      stores
+      stores,
+      triggers
     };
     if (format === "json") {
       return JSON.stringify(result, null, 2);
@@ -3741,6 +4143,42 @@ var IGNORED_DIRS3 = /* @__PURE__ */ new Set([
   ".vercel",
   ".analyze"
 ]);
+function resolveAreaId(target, config, allFiles) {
+  const targetLower = target.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+  if (config.areas[target]) {
+    return target;
+  }
+  for (const [id, areaConfig] of Object.entries(config.areas)) {
+    const name = areaConfig.name?.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+    if (name === targetLower) {
+      return id;
+    }
+  }
+  for (const [id, name] of Object.entries(AREA_NAMES)) {
+    const nameNormalized = name.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "");
+    if (nameNormalized === targetLower) {
+      return id;
+    }
+  }
+  for (const id of Object.keys(config.areas)) {
+    if (id.toLowerCase().includes(targetLower)) {
+      return id;
+    }
+  }
+  const detectedAreas = /* @__PURE__ */ new Set();
+  for (const filePath of allFiles) {
+    const areas2 = detectFileAreas(filePath, config);
+    for (const areaId of areas2) {
+      if (areaId.toLowerCase().includes(targetLower)) {
+        detectedAreas.add(areaId);
+      }
+    }
+  }
+  if (detectedAreas.size > 0) {
+    return [...detectedAreas][0];
+  }
+  return target;
+}
 async function area(target, options = {}) {
   const cwd = options.cwd || process.cwd();
   const format = options.format || "text";
@@ -3752,9 +4190,10 @@ async function area(target, options = {}) {
   try {
     const config = readConfig(cwd);
     const allFiles = getAllCodeFiles4(cwd);
+    const resolvedTarget = resolveAreaId(target, config, allFiles);
     const filteredFiles = allFiles.filter((filePath) => !isFileIgnored(filePath, config));
     const areaFiles = [];
-    const targetLower = target.toLowerCase();
+    const targetLower = resolvedTarget.toLowerCase();
     for (const filePath of filteredFiles) {
       const fileAreas = detectFileAreas(filePath, config);
       const belongsToArea = fileAreas.some(
@@ -3792,15 +4231,19 @@ async function area(target, options = {}) {
     for (const cat of Object.keys(byCategory)) {
       byCategory[cat].sort((a, b) => a.path.localeCompare(b.path));
     }
-    const realAreaId = findRealAreaId(target, filteredFiles, config);
+    const realAreaId = resolvedTarget !== target ? resolvedTarget : findRealAreaId(target, filteredFiles, config);
+    const finalAreaId = realAreaId || resolvedTarget;
+    const nameConversionMsg = resolvedTarget !== target ? `
+\u{1F4A1} Buscando \xE1rea "${getAreaName(finalAreaId, config)}" (ID: ${finalAreaId})
+` : "";
     const detectedArea = {
-      id: realAreaId || target,
-      name: getAreaName(realAreaId || target, config),
-      description: getAreaDescription(realAreaId || target, config),
+      id: finalAreaId,
+      name: getAreaName(finalAreaId, config),
+      description: getAreaDescription(finalAreaId, config),
       files: areaFiles,
       fileCount: areaFiles.length,
       categories,
-      isAutoDetected: !config.areas[realAreaId || target]
+      isAutoDetected: !config.areas[finalAreaId]
     };
     const result = {
       version: "1.0.0",
@@ -3811,7 +4254,8 @@ async function area(target, options = {}) {
     if (format === "json") {
       return JSON.stringify(result, null, 2);
     }
-    return formatAreaDetailText(result, { full, filterType });
+    const output = formatAreaDetailText(result, { full, filterType });
+    return nameConversionMsg + output;
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     throw new Error(`Erro ao executar area: ${message}`);
@@ -3926,9 +4370,11 @@ Ou edite manualmente o arquivo existente.
         patterns
       };
     }
+    const suggestedIgnore = detectSuggestedIgnorePatterns(allFiles);
     const newConfig = {
       $schema: "./areas.schema.json",
       version: "1.0.0",
+      ignore: suggestedIgnore,
       areas: generatedAreas,
       descriptions: {},
       settings: {
@@ -3943,7 +4389,12 @@ Ou edite manualmente o arquivo existente.
 \u2705 Arquivo criado: .analyze/areas.config.json
 
 \u{1F4E6} \xC1reas detectadas: ${sortedAreas.length}
-
+`;
+    if (suggestedIgnore.length > 0) {
+      out += `\u{1F6AB} Padr\xF5es ignorados: ${suggestedIgnore.length}
+`;
+    }
+    out += `
 `;
     for (const [areaId, files] of sortedAreas.slice(0, 15)) {
       const name = getAreaName(areaId, newConfig);
@@ -3963,6 +4414,15 @@ Ou edite manualmente o arquivo existente.
    Use 'ai-tool areas' para ver detalhes
 `;
     }
+    if (suggestedIgnore.length > 0) {
+      out += `
+\u{1F4CB} Padr\xF5es adicionados ao ignore:
+`;
+      for (const pattern of suggestedIgnore) {
+        out += `   \u2022 ${pattern}
+`;
+      }
+    }
     out += `
 \u{1F4A1} Edite o arquivo para:
    - Renomear \xE1reas (campo "name")
@@ -4004,6 +4464,28 @@ function inferPatternsFromFiles(files) {
   }
   return [...patterns].sort();
 }
+function detectSuggestedIgnorePatterns(files) {
+  const patterns = [];
+  if (files.some((f) => f.includes("functions/lib/"))) {
+    patterns.push("functions/lib/**");
+  }
+  const testCount = files.filter((f) => /\.(test|spec)\.(ts|tsx|js|jsx)$/.test(f)).length;
+  if (testCount > 3) {
+    patterns.push("**/*.test.{ts,tsx,js,jsx}");
+    patterns.push("**/*.spec.{ts,tsx,js,jsx}");
+  }
+  const dtsCount = files.filter((f) => f.endsWith(".d.ts")).length;
+  if (dtsCount > 2) {
+    patterns.push("**/*.d.ts");
+  }
+  const configCount = files.filter(
+    (f) => /\.(config|conf)\.(ts|js|mjs|cjs)$/.test(f)
+  ).length;
+  if (configCount > 2) {
+    patterns.push("**/*.config.{ts,js,mjs,cjs}");
+  }
+  return patterns;
+}
 function getAllCodeFiles5(dir, files = [], baseDir = dir) {
   try {
     const entries = readdirSync6(dir);
@@ -4031,6 +4513,442 @@ function getAllCodeFiles5(dir, files = [], baseDir = dir) {
   return files;
 }
 
+// src/commands/functions.ts
+async function functions(options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const format = options.format || "text";
+  const useCache = options.cache !== false;
+  const filterTrigger = options.trigger;
+  if (!isFirebaseProject(cwd)) {
+    const errorMsg = "Este n\xE3o \xE9 um projeto Firebase.\nN\xE3o foi encontrado .firebaserc ou firebase.json";
+    return format === "json" ? JSON.stringify({ error: errorMsg }) : `\u274C ${errorMsg}`;
+  }
+  if (!hasFirebaseFunctions(cwd)) {
+    const errorMsg = "Projeto Firebase sem Cloud Functions.\nN\xE3o foi encontrado functions/src/index.ts";
+    return format === "json" ? JSON.stringify({ error: errorMsg }) : `\u274C ${errorMsg}`;
+  }
+  try {
+    let index;
+    if (useCache && isCacheValid(cwd)) {
+      const cached = getCachedSymbolsIndex(cwd);
+      if (cached && cached.symbolsByName) {
+        index = cached;
+      } else {
+        index = indexProject(cwd);
+        cacheSymbolsIndex(cwd, index);
+        updateCacheMeta(cwd);
+      }
+    } else {
+      index = indexProject(cwd);
+      if (useCache) {
+        cacheSymbolsIndex(cwd, index);
+        updateCacheMeta(cwd);
+      }
+    }
+    const funcs = [];
+    for (const fileData of Object.values(index.files)) {
+      if (!fileData.path.includes("functions/src/")) continue;
+      for (const symbol of fileData.symbols) {
+        if (symbol.kind === "trigger") {
+          funcs.push({
+            name: symbol.name,
+            file: symbol.file,
+            line: symbol.line,
+            triggerType: symbol.triggerInfo?.triggerType || "unknown",
+            triggerPath: symbol.triggerInfo?.triggerPath,
+            triggerSchedule: symbol.triggerInfo?.triggerSchedule,
+            isExported: symbol.isExported
+          });
+        }
+      }
+    }
+    const filtered = filterTrigger ? funcs.filter(
+      (f) => f.triggerType.toLowerCase().includes(filterTrigger.toLowerCase())
+    ) : funcs;
+    const byTrigger = {};
+    const triggerCounts = {};
+    for (const func of filtered) {
+      if (!byTrigger[func.triggerType]) {
+        byTrigger[func.triggerType] = [];
+        triggerCounts[func.triggerType] = 0;
+      }
+      byTrigger[func.triggerType].push(func);
+      triggerCounts[func.triggerType]++;
+    }
+    const result = {
+      version: "1.0.0",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      cwd,
+      isFirebaseProject: true,
+      hasFunctions: true,
+      functions: filtered,
+      byTrigger,
+      summary: {
+        total: filtered.length,
+        exported: filtered.filter((f) => f.isExported).length,
+        byTrigger: triggerCounts
+      }
+    };
+    if (format === "json") {
+      return JSON.stringify(result, null, 2);
+    }
+    return formatFunctionsText(result);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Erro ao executar functions: ${message}`);
+  }
+}
+function formatFunctionsText(result) {
+  let out = "";
+  out += `
+`;
+  out += `\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557
+`;
+  out += `\u2551                    \u26A1 CLOUD FUNCTIONS                        \u2551
+`;
+  out += `\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D
+
+`;
+  out += `\u{1F4CA} RESUMO
+`;
+  out += `   Total: ${result.summary.total} functions
+`;
+  out += `   Exportadas: ${result.summary.exported}
+`;
+  if (result.summary.total > 0) {
+    out += `
+   \u{1F4A1} Filtros dispon\xEDveis:
+`;
+    out += `      ai-tool functions --trigger=onCall
+`;
+    out += `      ai-tool functions --trigger=onDocumentCreated
+`;
+  }
+  out += `
+`;
+  if (result.summary.total === 0) {
+    out += `   \u26A0\uFE0F  NENHUMA CLOUD FUNCTION DETECTADA
+
+`;
+    out += `   Poss\xEDveis causas:
+`;
+    out += `      1. O projeto n\xE3o \xE9 Firebase (n\xE3o encontrou .firebaserc ou firebase.json)
+`;
+    out += `      2. N\xE3o h\xE1 arquivo functions/src/index.ts
+`;
+    out += `      3. Os triggers n\xE3o usam padr\xF5es v2 (onCall, onDocumentCreated, etc)
+`;
+    out += `      4. O cache est\xE1 desatualizado \u2192 tente: ai-tool functions --no-cache
+`;
+    out += `      5. Para debug: DEBUG_ANALYZE=true ai-tool functions
+
+`;
+    out += `   Padr\xF5es suportados:
+`;
+    out += `      export const minhaFunc = onCall((request) => { ... })
+`;
+    out += `      export const minhaFunc = onDocumentCreated("path", (event) => { ... })
+
+`;
+    out += `   Documenta\xE7\xE3o: https://firebase.google.com/docs/functions
+`;
+    return out;
+  }
+  out += `\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501
+
+`;
+  const triggerOrder = [
+    // HTTPS
+    "onCall",
+    "onRequest",
+    // Firestore
+    "onDocumentCreated",
+    "onDocumentCreatedWithAuthContext",
+    "onDocumentUpdated",
+    "onDocumentUpdatedWithAuthContext",
+    "onDocumentDeleted",
+    "onDocumentDeletedWithAuthContext",
+    "onDocumentWritten",
+    "onDocumentWrittenWithAuthContext",
+    // Realtime Database
+    "onValueCreated",
+    "onValueUpdated",
+    "onValueDeleted",
+    "onValueWritten",
+    // Scheduler
+    "onSchedule",
+    // Storage
+    "onObjectFinalized",
+    "onObjectArchived",
+    "onObjectDeleted",
+    "onMetadataUpdated",
+    // Pub/Sub
+    "onMessagePublished",
+    // Identity
+    "beforeUserCreated",
+    "beforeUserSignedIn"
+  ];
+  const sortedTriggers = Object.keys(result.byTrigger).sort((a, b) => {
+    const aIdx = triggerOrder.indexOf(a);
+    const bIdx = triggerOrder.indexOf(b);
+    if (aIdx === -1 && bIdx === -1) return a.localeCompare(b);
+    if (aIdx === -1) return 1;
+    if (bIdx === -1) return -1;
+    return aIdx - bIdx;
+  });
+  for (const trigger of sortedTriggers) {
+    const funcs = result.byTrigger[trigger];
+    const icon = getTriggerIcon(trigger);
+    out += `${icon} ${trigger} (${funcs.length})
+
+`;
+    for (const func of funcs) {
+      const exportTag = func.isExported ? "" : " [n\xE3o exportada]";
+      out += `   ${func.name}${exportTag}
+`;
+      out += `      \u{1F4C1} ${func.file}:${func.line}
+`;
+      if (func.triggerPath) {
+        out += `      \u{1F4CD} path: ${func.triggerPath}
+`;
+      }
+      if (func.triggerSchedule) {
+        out += `      \u23F0 schedule: ${func.triggerSchedule}
+`;
+      }
+    }
+    out += `
+`;
+  }
+  return out;
+}
+function getTriggerIcon(trigger) {
+  if (trigger.includes("Call") || trigger.includes("Request")) return "\u{1F310}";
+  if (trigger.includes("Document") || trigger.includes("Value")) return "\u{1F525}";
+  if (trigger.includes("Schedule")) return "\u23F0";
+  if (trigger.includes("Object") || trigger.includes("Metadata")) return "\u{1F4E6}";
+  if (trigger.includes("Message") || trigger.includes("Pub")) return "\u{1F4E8}";
+  if (trigger.includes("User") || trigger.includes("before")) return "\u{1F464}";
+  if (trigger.includes("Alert") || trigger.includes("Issue")) return "\u{1F6A8}";
+  if (trigger.includes("Config")) return "\u2699\uFE0F";
+  if (trigger.includes("Task")) return "\u{1F4CB}";
+  if (trigger.includes("Test")) return "\u{1F9EA}";
+  return "\u26A1";
+}
+
+// src/commands/find.ts
+async function find(query, options = {}) {
+  const cwd = options.cwd || process.cwd();
+  const format = options.format || "text";
+  const filterType = options.type || "all";
+  const filterArea = options.area;
+  const defOnly = options.def ?? false;
+  const refsOnly = options.refs ?? false;
+  const useCache = options.cache !== false;
+  const listAllMode = !query && defOnly && filterType && filterType !== "all";
+  if (!query && !listAllMode) {
+    throw new Error("Query \xE9 obrigat\xF3ria. Exemplo: ai-tool find useAuth\n   Ou use --def para listar todos de um tipo: ai-tool find --type=trigger --def");
+  }
+  try {
+    let index;
+    let fromCache = false;
+    if (useCache && isCacheValid(cwd)) {
+      const cached = getCachedSymbolsIndex(cwd);
+      if (cached && cached.symbolsByName) {
+        index = cached;
+        fromCache = true;
+      } else {
+        index = indexProject(cwd);
+        cacheSymbolsIndex(cwd, index);
+        updateCacheMeta(cwd);
+      }
+    } else {
+      index = indexProject(cwd);
+      if (useCache) {
+        cacheSymbolsIndex(cwd, index);
+        updateCacheMeta(cwd);
+      }
+    }
+    let allowedFiles = null;
+    if (filterArea) {
+      const config = readConfig(cwd);
+      const areaLower = filterArea.toLowerCase();
+      allowedFiles = /* @__PURE__ */ new Set();
+      for (const filePath of Object.keys(index.files)) {
+        if (isFileIgnored(filePath, config)) continue;
+        const fileAreas = detectFileAreas(filePath, config);
+        const belongsToArea = fileAreas.some(
+          (a) => a.toLowerCase() === areaLower || a.toLowerCase().includes(areaLower)
+        );
+        if (belongsToArea) {
+          allowedFiles.add(filePath);
+        }
+      }
+      if (allowedFiles.size === 0) {
+        return format === "json" ? JSON.stringify({ error: `Nenhum arquivo encontrado na \xE1rea "${filterArea}"` }) : `\u274C Nenhum arquivo encontrado na \xE1rea "${filterArea}"`;
+      }
+    }
+    const matches = searchInIndex(index, query, filterType, allowedFiles);
+    let definition = null;
+    let references = [];
+    for (const match of matches) {
+      if (match.matchType === "definition") {
+        if (!definition) {
+          definition = match;
+        }
+      } else {
+        references.push(match);
+      }
+    }
+    if (defOnly) {
+      references = [];
+    }
+    if (refsOnly) {
+      definition = null;
+    }
+    const uniqueFiles = /* @__PURE__ */ new Set();
+    if (definition) uniqueFiles.add(definition.file);
+    for (const ref of references) {
+      uniqueFiles.add(ref.file);
+    }
+    const result = {
+      version: "1.0.0",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      query,
+      filters: {
+        type: filterType !== "all" ? filterType : void 0,
+        area: filterArea,
+        defOnly,
+        refsOnly
+      },
+      definition,
+      references,
+      summary: {
+        definitions: definition ? 1 : 0,
+        references: references.length,
+        files: uniqueFiles.size
+      },
+      fromCache
+    };
+    if (format === "json") {
+      return JSON.stringify(result, null, 2);
+    }
+    return formatFindText(result);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Erro ao executar find: ${message}`);
+  }
+}
+function searchInIndex(index, query, filterType, allowedFiles) {
+  const matches = [];
+  const queryLower = query?.toLowerCase() || "";
+  const processedSymbols = /* @__PURE__ */ new Set();
+  const listAllMode = !query && filterType && filterType !== "all";
+  for (const [name, symbols] of Object.entries(index.symbolsByName)) {
+    const nameLower = name.toLowerCase();
+    const shouldInclude = listAllMode || nameLower === queryLower || nameLower.includes(queryLower);
+    if (shouldInclude) {
+      for (const symbol of symbols) {
+        if (allowedFiles && !allowedFiles.has(symbol.file)) continue;
+        if (!matchesType(symbol.kind, filterType)) continue;
+        const key = `${symbol.file}:${symbol.line}:${symbol.name}`;
+        if (processedSymbols.has(key)) continue;
+        processedSymbols.add(key);
+        const fileData = index.files[symbol.file];
+        matches.push({
+          file: symbol.file,
+          line: symbol.line,
+          column: 0,
+          code: symbol.signature,
+          matchType: "definition",
+          symbolType: mapKindToSymbolType(symbol.kind),
+          category: fileData?.category || "other"
+        });
+      }
+    }
+  }
+  if (!listAllMode) {
+    for (const [filePath, fileData] of Object.entries(index.files)) {
+      if (allowedFiles && !allowedFiles.has(filePath)) continue;
+      for (const imp of fileData.imports) {
+        for (const spec of imp.specifiers) {
+          const specLower = spec.toLowerCase();
+          if (specLower === queryLower || specLower.includes(queryLower)) {
+            const key = `import:${filePath}:${spec}:${imp.source}`;
+            if (processedSymbols.has(key)) continue;
+            processedSymbols.add(key);
+            matches.push({
+              file: filePath,
+              line: 1,
+              // Imports geralmente estão no topo
+              column: 0,
+              code: `import { ${spec} } from '${imp.source}'`,
+              matchType: "import",
+              symbolType: inferSymbolTypeFromName(spec),
+              category: fileData.category
+            });
+          }
+        }
+      }
+    }
+  }
+  matches.sort((a, b) => {
+    const order = { definition: 0, import: 1, usage: 2 };
+    const orderDiff = order[a.matchType] - order[b.matchType];
+    if (orderDiff !== 0) return orderDiff;
+    return a.file.localeCompare(b.file) || a.line - b.line;
+  });
+  return matches;
+}
+function matchesType(kind, filter) {
+  if (filter === "all") return true;
+  switch (filter) {
+    case "function":
+      return kind === "function" || kind === "trigger";
+    case "type":
+      return kind === "type" || kind === "interface" || kind === "enum";
+    case "const":
+      return kind === "const";
+    case "component":
+      return kind === "component";
+    case "hook":
+      return kind === "hook";
+    case "trigger":
+      return kind === "trigger";
+    default:
+      return true;
+  }
+}
+function mapKindToSymbolType(kind) {
+  switch (kind) {
+    case "function":
+      return "function";
+    case "hook":
+      return "hook";
+    case "component":
+      return "component";
+    case "type":
+    case "interface":
+    case "enum":
+      return "type";
+    case "const":
+      return "const";
+    case "trigger":
+      return "trigger";
+    default:
+      return "function";
+  }
+}
+function inferSymbolTypeFromName(name) {
+  if (name.startsWith("use") && name.length > 3 && name[3] === name[3].toUpperCase()) {
+    return "hook";
+  }
+  if (name[0] === name[0].toUpperCase()) {
+    return "type";
+  }
+  return "function";
+}
+
 // src/index.ts
 import { createRequire } from "module";
 var require2 = createRequire(import.meta.url);
@@ -4042,7 +4960,6 @@ export {
   categoryIcons,
   isEntryPoint,
   isCodeFile,
-  formatFindText,
   isFirebaseProject,
   hasFirebaseFunctions,
   isExportedCloudFunction,
@@ -4050,10 +4967,7 @@ export {
   clearFirebaseCache,
   getCacheDir,
   isCacheValid,
-  updateCacheMeta,
   invalidateCache,
-  cacheSymbolsIndex,
-  getCachedSymbolsIndex,
   configExists,
   readConfig,
   writeConfig,
@@ -4065,7 +4979,6 @@ export {
   KEYWORD_PATTERNS,
   AREA_NAMES,
   AREA_DESCRIPTIONS,
-  isFileIgnored,
   detectFileAreas,
   getAreaName,
   getAreaDescription,
@@ -4084,11 +4997,12 @@ export {
   formatInvalidCommand,
   impact,
   suggest,
-  indexProject,
   context,
   areaContext,
   areas,
   area,
   areasInit,
+  find,
+  functions,
   VERSION
 };