@justmpm/ai-tool 0.6.0 → 0.7.0

package/dist/{chunk-UDT7TLSN.js → chunk-CRVOX3U4.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}
 `;
     }
   }
@@ -799,6 +822,7 @@ function formatAreaDetailText(result, options = {}) {
     "type",
     "config",
     "test",
+    "cloud-function",
     "other"
   ];
   const catParts = [];
@@ -1057,6 +1081,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 +1121,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 +1607,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 +1667,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 +1724,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 +1784,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 +2828,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 +2892,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 +3024,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 +3046,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 +3059,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 +3071,7 @@ function extractFunctions(sourceFile) {
       }
     }
   }
-  return functions;
+  return functions2;
 }
 function extractTypes(sourceFile) {
   const types = [];
@@ -3035,6 +3178,62 @@ 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);
   const project = createProject2(cwd);
@@ -3084,7 +3283,7 @@ function indexProject(cwd) {
       if (!name) continue;
       const isExported = func.isExported();
       const params = func.getParameters().map((p) => p.getName());
-      const returnType = simplifyType2(func.getReturnType().getText());
+      const returnType = simplifyType2(safeGetReturnType(func));
       const kind = inferSymbolKind(name, "function");
       const symbol = {
         name,
@@ -3116,7 +3315,7 @@ function indexProject(cwd) {
           const funcLike = init.asKind(SyntaxKind2.ArrowFunction) || init.asKind(SyntaxKind2.FunctionExpression);
           if (!funcLike) continue;
           const params = funcLike.getParameters().map((p) => p.getName());
-          const returnType = simplifyType2(funcLike.getReturnType().getText());
+          const returnType = simplifyType2(safeGetReturnType(funcLike));
           const kind = inferSymbolKind(name, "function");
           const symbol = {
             name,
@@ -3136,6 +3335,48 @@ function indexProject(cwd) {
           if (isExported) {
             exports.push(name);
           }
+        } else if (initKind === SyntaxKind2.CallExpression) {
+          const triggerName = extractFirebaseTriggerName(init);
+          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;
@@ -3189,7 +3430,7 @@ function indexProject(cwd) {
         kind: "type",
         signature: `${isExported ? "export " : ""}type ${name}`,
         isExported,
-        definition: simplifyType2(typeAlias.getType().getText())
+        definition: simplifyType2(safeGetTypeText(() => typeAlias.getType()))
       };
       symbols.push(symbol);
       if (!symbolsByName[name]) {
@@ -3290,13 +3531,70 @@ 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(`(?:^|\\.)${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, "");
   if (simplified.length > 80) {
     simplified = simplified.slice(0, 77) + "...";
   }
   return simplified;
 }
+function safeGetTypeText(getTypeFn) {
+  try {
+    const type = getTypeFn();
+    if (!type) return "unknown";
+    return type.getText();
+  } catch {
+    return "unknown";
+  }
+}
+function safeGetReturnType(node) {
+  try {
+    const returnType = node.getReturnType();
+    if (!returnType) return "unknown";
+    return returnType.getText();
+  } catch {
+    return "unknown";
+  }
+}
 function truncateCode(code, maxLen) {
   const oneLine = code.replace(/\s+/g, " ").trim();
   if (oneLine.length <= maxLen) return oneLine;
@@ -3310,7 +3608,7 @@ function formatInterfaceDefinition2(iface) {
   }
   const props = iface.getProperties();
   for (const prop of props.slice(0, 10)) {
-    const propType = simplifyType2(prop.getType().getText());
+    const propType = simplifyType2(safeGetTypeText(() => prop.getType()));
     parts.push(`${prop.getName()}: ${propType}`);
   }
   if (props.length > 10) {
@@ -3335,7 +3633,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 = {
@@ -3345,7 +3643,7 @@ async function context(target, options = {}) {
       category: detectCategory(targetPath),
       imports,
       exports,
-      functions,
+      functions: functions2,
       types
     };
     if (format === "json") {
@@ -3478,10 +3776,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;
@@ -3526,7 +3825,7 @@ async function areaContext(areaName, options = {}) {
                 returns: symbol.returnType || "unknown"
               });
             } else {
-              functions.push({
+              functions2.push({
                 name: symbol.name,
                 file: filePath,
                 line: symbol.line,
@@ -3545,6 +3844,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;
         }
       }
     }
@@ -3560,10 +3869,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);
@@ -4012,6 +4322,406 @@ 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 += `   \u26A0\uFE0F  Nenhuma Cloud Function detectada.
+`;
+    out += `   Verifique se seus triggers usam padr\xE3o Firebase v2 (onCall, onDocumentCreated, etc).
+`;
+    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;
+  if (!query || query.trim().length === 0) {
+    throw new Error("Query \xE9 obrigat\xF3ria. Exemplo: ai-tool find useAuth");
+  }
+  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();
+  for (const [name, symbols] of Object.entries(index.symbolsByName)) {
+    const nameLower = name.toLowerCase();
+    if (nameLower === queryLower || nameLower.includes(queryLower)) {
+      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"
+        });
+      }
+    }
+  }
+  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);
@@ -4023,7 +4733,6 @@ export {
   categoryIcons,
   isEntryPoint,
   isCodeFile,
-  formatFindText,
   isFirebaseProject,
   hasFirebaseFunctions,
   isExportedCloudFunction,
@@ -4031,10 +4740,7 @@ export {
   clearFirebaseCache,
   getCacheDir,
   isCacheValid,
-  updateCacheMeta,
   invalidateCache,
-  cacheSymbolsIndex,
-  getCachedSymbolsIndex,
   configExists,
   readConfig,
   writeConfig,
@@ -4046,7 +4752,6 @@ export {
   KEYWORD_PATTERNS,
   AREA_NAMES,
   AREA_DESCRIPTIONS,
-  isFileIgnored,
   detectFileAreas,
   getAreaName,
   getAreaDescription,
@@ -4065,11 +4770,12 @@ export {
   formatInvalidCommand,
   impact,
   suggest,
-  indexProject,
   context,
   areaContext,
   areas,
   area,
   areasInit,
+  find,
+  functions,
   VERSION
 };