@justmpm/ai-tool 0.3.0 → 0.3.2

package/README.md

@@ -1,29 +1,27 @@
 # ai-tool
 
-Ferramenta de análise de dependências e impacto para projetos TypeScript/JavaScript.
+Ferramenta de analise de dependencias e impacto para projetos TypeScript/JavaScript.
 
-Usa [Skott](https://github.com/antoine-coulon/skott) + [Knip](https://knip.dev) internamente para análise precisa.
+Usa [Skott](https://github.com/antoine-coulon/skott) + [Knip](https://knip.dev) + [ts-morph](https://ts-morph.com) internamente.
 
-## Instalação
+## Instalacao
 
 ```bash
 # Via npx (sem instalar)
-npx ai-tool map
-npx ai-tool dead
-npx ai-tool impact Button
+npx @justmpm/ai-tool map
 
 # Ou instalar globalmente
-npm install -g ai-tool
+npm install -g @justmpm/ai-tool
 
 # Ou como devDependency
-npm install -D ai-tool
+npm install -D @justmpm/ai-tool
 ```
 
 ## Comandos
 
 ### `map` - Mapa do Projeto
 
-Gera um mapa completo do projeto com categorização de arquivos.
+Gera um mapa completo do projeto com categorizacao de arquivos.
 
 ```bash
 ai-tool map
@@ -32,13 +30,13 @@ ai-tool map --format=json
 
 **Output:**
 - Total de arquivos e pastas
-- Categorização automática (component, hook, service, util, etc.)
+- Categorizacao automatica (component, hook, service, util, etc.)
 - Estrutura de pastas
-- Dependências circulares detectadas
+- Dependencias circulares detectadas
 
-### `dead` - Código Morto
+### `dead` - Codigo Morto
 
-Detecta arquivos, exports e dependências não utilizados.
+Detecta arquivos, exports e dependencias nao utilizados.
 
 ```bash
 ai-tool dead
@@ -47,13 +45,13 @@ ai-tool dead --fix  # Remove automaticamente
 ```
 
 **Detecta:**
-- Arquivos órfãos (ninguém importa)
-- Exports não utilizados
-- Dependências npm não usadas
+- Arquivos orfaos (ninguem importa)
+- Exports nao utilizados
+- Dependencias npm nao usadas
 
-### `impact` - Análise de Impacto
+### `impact` - Analise de Impacto
 
-Analisa o impacto de modificar um arquivo específico.
+Analisa o impacto de modificar um arquivo especifico.
 
 ```bash
 ai-tool impact Button
@@ -62,100 +60,159 @@ ai-tool impact useAuth --format=json
 ```
 
 **Output:**
-- **Upstream**: Quem importa este arquivo (afetados por mudanças)
-- **Downstream**: O que este arquivo importa (dependências)
-- **Riscos**: Arquivo crítico, dependências circulares, etc.
-- **Sugestões**: Recomendações para modificação segura
+- **Upstream**: Quem importa este arquivo (afetados por mudancas)
+- **Downstream**: O que este arquivo importa (dependencias)
+- **Riscos**: Arquivo critico, dependencias circulares, etc.
+- **Sugestoes**: Recomendacoes para modificacao segura
 
-## Uso Programático
+### `suggest` - Sugestao de Leitura
+
+Sugere arquivos para ler ANTES de modificar um arquivo.
+
+```bash
+ai-tool suggest Button
+ai-tool suggest src/hooks/useAuth.ts --limit=5
+```
+
+**Prioridades:**
+- **Critical**: Tipos/interfaces usados pelo arquivo
+- **High**: Dependencias diretas (imports)
+- **Medium**: Upstream (quem usa o arquivo)
+- **Low**: Testes relacionados
+
+### `context` - Contexto do Arquivo
+
+Extrai assinaturas de funcoes e tipos SEM a implementacao.
+
+```bash
+ai-tool context Button
+ai-tool context src/hooks/useAuth.ts --format=json
+```
+
+**Extrai:**
+- Imports com specifiers
+- Exports do arquivo
+- Funcoes com parametros e tipos de retorno
+- Interfaces, types e enums com definicoes
+
+Ideal para entender rapidamente a API publica de um arquivo.
+
+## Servidor MCP
+
+Integra com Claude Desktop e outras ferramentas MCP.
+
+```bash
+ai-tool --mcp
+```
+
+**Tools expostas:**
+- `aitool_project_map` - Mapa do projeto
+- `aitool_dead_code` - Codigo morto
+- `aitool_impact_analysis` - Analise de impacto
+- `aitool_suggest_reads` - Sugestao de leitura
+- `aitool_file_context` - Contexto do arquivo
+
+### Configuracao Claude Code
+
+Adicione ao `.mcp.json` do projeto ou ao arquivo global `~/.claude/settings.json`:
+
+```json
+{
+  "mcpServers": {
+    "analyze": {
+      "command": "npx",
+      "args": ["-y", "@justmpm/ai-tool", "--mcp"]
+    }
+  }
+}
+```
+
+### Configuracao Claude Desktop
+
+Adicione ao `claude_desktop_config.json`:
+
+**Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
+**macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
+
+```json
+{
+  "mcpServers": {
+    "analyze": {
+      "command": "npx",
+      "args": ["-y", "@justmpm/ai-tool", "--mcp"]
+    }
+  }
+}
+```
+
+## Uso Programatico
 
 ```typescript
-import { map, dead, impact } from "ai-tool";
+import { map, dead, impact, suggest, context } from "@justmpm/ai-tool";
 
 // Mapa do projeto
 const projectMap = await map({ format: "json" });
 
-// Código morto
+// Codigo morto
 const deadCode = await dead({ format: "json" });
 
-// Análise de impacto
-const analysis = await impact("src/components/Button.tsx", {
-  format: "json"
-});
+// Analise de impacto
+const analysis = await impact("Button", { format: "json" });
+
+// Sugestao de leitura
+const suggestions = await suggest("Button", { limit: 5 });
+
+// Contexto do arquivo
+const fileContext = await context("Button", { format: "json" });
 ```
 
-## Opções
+## Opcoes
 
-| Opção | Descrição | Default |
+| Opcao | Descricao | Default |
 |-------|-----------|---------|
-| `--format=text\|json` | Formato de saída | `text` |
-| `--cwd=<path>` | Diretório do projeto | `process.cwd()` |
-| `--fix` | Remove código morto (só para `dead`) | `false` |
+| `--format=text\|json` | Formato de saida | `text` |
+| `--cwd=<path>` | Diretorio do projeto | `process.cwd()` |
+| `--no-cache` | Ignora cache | `false` |
+| `--fix` | Remove codigo morto (so `dead`) | `false` |
+| `--limit=<n>` | Limite de sugestoes (so `suggest`) | `10` |
+| `--mcp` | Inicia servidor MCP | - |
 
 ## Categorias de Arquivos
 
-O ai-tool categoriza automaticamente os arquivos:
-
-| Categoria | Descrição |
+| Categoria | Descricao |
 |-----------|-----------|
-| `page` | Páginas (Next.js, etc.) |
+| `page` | Paginas (Next.js, etc.) |
 | `layout` | Layouts |
 | `route` | Rotas de API |
 | `component` | Componentes React/Vue |
 | `hook` | React Hooks |
-| `service` | Serviços/API |
-| `store` | Estado global (Redux, Zustand, Context) |
-| `util` | Utilitários |
+| `service` | Servicos/API |
+| `store` | Estado global |
+| `util` | Utilitarios |
 | `type` | Tipos TypeScript |
-| `config` | Configurações |
+| `config` | Configuracoes |
 | `test` | Testes |
 | `other` | Outros |
 
-## Integração com IA
+## Cache
 
-Este pacote foi criado para ser usado com ferramentas de IA como Claude Code, OpenCode, etc.
+Resultados sao salvos em `.analyze/` para acelerar execucoes futuras.
 
-Exemplo de tool para OpenCode:
-
-```typescript
-import { tool } from "@opencode-ai/plugin";
-import { execSync } from "child_process";
-
-export default tool({
-  description: `Analisa dependências e impacto do projeto.
-
-  COMANDOS:
-  - map: Mapa do projeto
-  - dead: Código morto
-  - impact <arquivo>: Análise de impacto`,
-
-  args: {
-    command: tool.schema.enum(["map", "dead", "impact"]),
-    target: tool.schema.string().optional(),
-    format: tool.schema.enum(["text", "json"]).optional()
-  },
-
-  async execute({ command, target, format }) {
-    const fmt = format || "text";
-    const cmd = target
-      ? `npx ai-tool ${command} "${target}" --format=${fmt}`
-      : `npx ai-tool ${command} --format=${fmt}`;
-
-    return execSync(cmd, { encoding: "utf-8" });
-  }
-});
-```
+- Cache e invalidado automaticamente quando arquivos mudam
+- Use `--no-cache` para forcar regeneracao
+- Adicione `.analyze/` ao `.gitignore`
 
 ## Requisitos
 
 - Node.js >= 18.0.0
-- TypeScript/JavaScript project
+- Projeto TypeScript/JavaScript
 
-## Créditos
+## Creditos
 
-- [Skott](https://github.com/antoine-coulon/skott) - Análise de dependências
-- [Knip](https://knip.dev) - Detecção de código morto
+- [Skott](https://github.com/antoine-coulon/skott) - Analise de dependencias
+- [Knip](https://knip.dev) - Deteccao de codigo morto
+- [ts-morph](https://ts-morph.com) - Analise AST
 
-## Licença
+## Licenca
 
 MIT - [Koda AI Studio](https://kodaai.app)

package/dist/{chunk-BIT47QXF.js → chunk-EONUMGCN.js}

@@ -252,6 +252,18 @@ function formatDeadText(result) {
 `;
     }
     out += `
+`;
+  }
+  if (result.filters?.firebase.detected) {
+    out += `\u{1F525} FIREBASE CLOUD FUNCTIONS
+`;
+    out += `   Projeto Firebase detectado.
+`;
+    if (result.filters.firebase.excludedCount > 0) {
+      out += `   ${result.filters.firebase.excludedCount} arquivo(s) filtrado(s) (exportados em functions/src/index.ts)
+`;
+    }
+    out += `
 `;
   }
   out += `\u{1F4A1} SUGEST\xC3O
@@ -587,8 +599,98 @@ function formatContextText(result) {
 }
 
 // src/cache/index.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync, statSync, readdirSync } from "fs";
-import { join, extname } from "path";
+import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, writeFileSync, statSync, readdirSync } from "fs";
+import { join as join2, extname } from "path";
+
+// src/utils/firebase.ts
+import { existsSync, readFileSync } from "fs";
+import { join, relative, normalize } from "path";
+var indexContentCache = null;
+function isFirebaseProject(cwd) {
+  const firebaserc = join(cwd, ".firebaserc");
+  const firebaseJson = join(cwd, "firebase.json");
+  return existsSync(firebaserc) || existsSync(firebaseJson);
+}
+function hasFirebaseFunctions(cwd) {
+  if (!isFirebaseProject(cwd)) {
+    return false;
+  }
+  const functionsIndexPath = join(cwd, "functions", "src", "index.ts");
+  return existsSync(functionsIndexPath);
+}
+function getFunctionsExports(cwd) {
+  const functionsIndexPath = join(cwd, "functions", "src", "index.ts");
+  if (indexContentCache && indexContentCache.cwd === cwd) {
+    return indexContentCache.exports;
+  }
+  if (!existsSync(functionsIndexPath)) {
+    return /* @__PURE__ */ new Set();
+  }
+  try {
+    const content = readFileSync(functionsIndexPath, "utf-8");
+    const exports = /* @__PURE__ */ new Set();
+    const namedExportRegex = /export\s*\{[^}]+\}\s*from\s*["']\.\/([^"']+)["']/g;
+    let match;
+    while ((match = namedExportRegex.exec(content)) !== null) {
+      const modulePath = match[1].replace(/\.js$/, "").replace(/\.ts$/, "");
+      exports.add(modulePath);
+    }
+    const starExportRegex = /export\s*\*\s*from\s*["']\.\/([^"']+)["']/g;
+    while ((match = starExportRegex.exec(content)) !== null) {
+      const modulePath = match[1].replace(/\.js$/, "").replace(/\.ts$/, "");
+      exports.add(modulePath);
+    }
+    const importRegex = /import\s*(?:\{[^}]+\}|\*\s+as\s+\w+)\s*from\s*["']\.\/([^"']+)["']/g;
+    while ((match = importRegex.exec(content)) !== null) {
+      const modulePath = match[1].replace(/\.js$/, "").replace(/\.ts$/, "");
+      exports.add(modulePath);
+    }
+    indexContentCache = { cwd, content, exports };
+    return exports;
+  } catch {
+    return /* @__PURE__ */ new Set();
+  }
+}
+function isExportedCloudFunction(filePath, cwd) {
+  const normalized = normalize(filePath).replace(/\\/g, "/");
+  if (!normalized.includes("functions/src/")) {
+    return false;
+  }
+  if (normalized.endsWith("functions/src/index.ts")) {
+    return false;
+  }
+  const functionsDir = join(cwd, "functions", "src");
+  const relativePath = relative(functionsDir, join(cwd, filePath)).replace(/\\/g, "/").replace(/\.ts$/, "").replace(/\.js$/, "");
+  const exports = getFunctionsExports(cwd);
+  if (exports.has(relativePath)) {
+    return true;
+  }
+  const parts = relativePath.split("/");
+  if (parts.length > 1 && exports.has(parts[0])) {
+    return true;
+  }
+  return false;
+}
+function filterCloudFunctionsFalsePositives(files, cwd) {
+  if (!hasFirebaseFunctions(cwd)) {
+    return { filtered: files, excluded: [] };
+  }
+  const filtered = [];
+  const excluded = [];
+  for (const file of files) {
+    if (isExportedCloudFunction(file, cwd)) {
+      excluded.push(file);
+    } else {
+      filtered.push(file);
+    }
+  }
+  return { filtered, excluded };
+}
+function clearFirebaseCache() {
+  indexContentCache = null;
+}
+
+// src/cache/index.ts
 var CACHE_DIR = ".analyze";
 var META_FILE = "meta.json";
 var GRAPH_FILE = "graph.json";
@@ -601,7 +703,7 @@ function calculateFilesHash(cwd) {
     try {
       const entries = readdirSync(dir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = join(dir, entry.name);
+        const fullPath = join2(dir, entry.name);
         if (entry.isDirectory()) {
           if (entry.name === "node_modules" || entry.name === ".git" || entry.name === ".next" || entry.name === "dist" || entry.name === ".analyze") {
             continue;
@@ -626,16 +728,16 @@ function calculateFilesHash(cwd) {
   return `${timestamps.length}-${Math.floor(sum)}`;
 }
 function getCacheDir(cwd) {
-  return join(cwd, CACHE_DIR);
+  return join2(cwd, CACHE_DIR);
 }
 function isCacheValid(cwd) {
   const cacheDir = getCacheDir(cwd);
-  const metaPath = join(cacheDir, META_FILE);
-  if (!existsSync(metaPath)) {
+  const metaPath = join2(cacheDir, META_FILE);
+  if (!existsSync2(metaPath)) {
     return false;
   }
   try {
-    const meta = JSON.parse(readFileSync(metaPath, "utf-8"));
+    const meta = JSON.parse(readFileSync2(metaPath, "utf-8"));
     const currentHash = calculateFilesHash(cwd);
     return meta.filesHash === currentHash;
   } catch {
@@ -643,22 +745,22 @@ function isCacheValid(cwd) {
   }
 }
 function readCache(cwd, file) {
-  const cachePath = join(getCacheDir(cwd), file);
-  if (!existsSync(cachePath)) {
+  const cachePath = join2(getCacheDir(cwd), file);
+  if (!existsSync2(cachePath)) {
     return null;
   }
   try {
-    return JSON.parse(readFileSync(cachePath, "utf-8"));
+    return JSON.parse(readFileSync2(cachePath, "utf-8"));
   } catch {
     return null;
   }
 }
 function writeCache(cwd, file, data) {
   const cacheDir = getCacheDir(cwd);
-  if (!existsSync(cacheDir)) {
+  if (!existsSync2(cacheDir)) {
     mkdirSync(cacheDir, { recursive: true });
   }
-  const cachePath = join(cacheDir, file);
+  const cachePath = join2(cacheDir, file);
   writeFileSync(cachePath, JSON.stringify(data, null, 2), "utf-8");
 }
 function updateCacheMeta(cwd) {
@@ -699,8 +801,9 @@ function getCachedDeadResult(cwd) {
   return readCache(cwd, DEAD_FILE);
 }
 function invalidateCache(cwd) {
-  const metaPath = join(getCacheDir(cwd), META_FILE);
-  if (existsSync(metaPath)) {
+  const metaPath = join2(getCacheDir(cwd), META_FILE);
+  clearFirebaseCache();
+  if (existsSync2(metaPath)) {
     try {
       writeFileSync(metaPath, "{}", "utf-8");
     } catch {
@@ -839,11 +942,15 @@ async function dead(options = {}) {
         knipOutput = {};
       }
     }
-    const deadFiles = (knipOutput.files || []).map((file) => ({
+    const rawFiles = knipOutput.files || [];
+    const { filtered: filteredFiles, excluded: excludedFunctions } = filterCloudFunctionsFalsePositives(rawFiles, cwd);
+    const deadFiles = filteredFiles.map((file) => ({
       path: file,
       category: detectCategory(file),
       type: "file"
     }));
+    const hasFirebase = hasFirebaseFunctions(cwd);
+    const firebaseInfo = hasFirebase ? { detected: true, excludedCount: excludedFunctions.length } : { detected: false, excludedCount: 0 };
     const deadExports = [];
     if (knipOutput.issues) {
       for (const issue of knipOutput.issues) {
@@ -873,7 +980,12 @@ async function dead(options = {}) {
       },
       files: deadFiles,
       exports: deadExports,
-      dependencies: deadDependencies
+      dependencies: deadDependencies,
+      // Metadata sobre filtros aplicados
+      filters: {
+        firebase: firebaseInfo,
+        excludedFiles: excludedFunctions
+      }
     };
     if (useCache) {
       cacheDeadResult(cwd, result);
@@ -1456,8 +1568,8 @@ function levenshteinDistance2(a, b) {
 }
 
 // src/commands/context.ts
-import { existsSync as existsSync2, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
-import { join as join2, resolve, basename, extname as extname2 } from "path";
+import { existsSync as existsSync3, readdirSync as readdirSync2, statSync as statSync2 } from "fs";
+import { join as join3, resolve, basename, extname as extname2 } from "path";
 
 // src/ts/extractor.ts
 import { Project, SyntaxKind } from "ts-morph";
@@ -1705,12 +1817,12 @@ var CODE_EXTENSIONS2 = /* @__PURE__ */ new Set([".ts", ".tsx", ".js", ".jsx", ".
 function findTargetFile3(target, cwd) {
   const normalizedTarget = target.replace(/\\/g, "/");
   const directPath = resolve(cwd, normalizedTarget);
-  if (existsSync2(directPath) && isCodeFile2(directPath)) {
+  if (existsSync3(directPath) && isCodeFile2(directPath)) {
     return normalizedTarget;
   }
   for (const ext of CODE_EXTENSIONS2) {
     const withExt = directPath + ext;
-    if (existsSync2(withExt)) {
+    if (existsSync3(withExt)) {
       return normalizedTarget + ext;
     }
   }
@@ -1740,7 +1852,7 @@ function getAllCodeFiles(dir, files = [], baseDir = dir) {
   try {
     const entries = readdirSync2(dir);
     for (const entry of entries) {
-      const fullPath = join2(dir, entry);
+      const fullPath = join3(dir, entry);
       if (shouldIgnore(entry)) {
         continue;
       }
@@ -1832,13 +1944,18 @@ function levenshteinDistance3(a, b) {
 }
 
 // src/index.ts
-var VERSION = "0.3.0";
+var VERSION = "0.3.2";
 
 export {
   detectCategory,
   categoryIcons,
   isEntryPoint,
   isCodeFile,
+  isFirebaseProject,
+  hasFirebaseFunctions,
+  isExportedCloudFunction,
+  filterCloudFunctionsFalsePositives,
+  clearFirebaseCache,
   getCacheDir,
   isCacheValid,
   invalidateCache,

package/dist/cli.js

@@ -7,7 +7,7 @@ import {
   impact,
   map,
   suggest
-} from "./chunk-BIT47QXF.js";
+} from "./chunk-EONUMGCN.js";
 
 // src/cli.ts
 var HELP = `
@@ -71,6 +71,11 @@ async function main() {
       positional.push(arg);
     }
   }
+  if (flags.mcp) {
+    const { startMcpServer } = await import("./server-K55EXKYX.js");
+    await startMcpServer();
+    return;
+  }
   if (flags.help || flags.h || positional.length === 0) {
     console.log(HELP);
     process.exit(0);
@@ -79,11 +84,6 @@ async function main() {
     console.log(`ai-tool v${VERSION}`);
     process.exit(0);
   }
-  if (flags.mcp) {
-    const { startMcpServer } = await import("./server-OAPPO22L.js");
-    await startMcpServer();
-    return;
-  }
   const command = positional[0];
   const target = positional[1];
   const format = flags.format || "text";

package/dist/index.d.ts

@@ -66,6 +66,14 @@ interface DeadResult {
         export: string;
     }>;
     dependencies: string[];
+    /** Informações sobre filtros aplicados (ex: Cloud Functions excluídas) */
+    filters?: {
+        firebase: {
+            detected: boolean;
+            excludedCount: number;
+        };
+        excludedFiles: string[];
+    };
 }
 interface ImpactFile {
     path: string;
@@ -162,6 +170,9 @@ declare function map(options?: MapOptions): Promise<string>;
 
 /**
  * Comando DEAD - Detecção de código morto usando Knip
+ *
+ * Inclui filtro inteligente para Firebase Cloud Functions que elimina
+ * falsos positivos de arquivos exportados via functions/src/index.ts
  */
 
 /**
@@ -221,6 +232,41 @@ declare function isEntryPoint(filePath: string): boolean;
  */
 declare function isCodeFile(filePath: string): boolean;
 
+/**
+ * Utilitários para detecção de Firebase Cloud Functions
+ *
+ * Resolve falsos positivos onde arquivos em functions/src/ são marcados
+ * como "órfãos" pelo Knip, mas na verdade são exportados via index.ts
+ * e deployados como Cloud Functions.
+ */
+/**
+ * Detecta se é um projeto Firebase (via .firebaserc ou firebase.json)
+ */
+declare function isFirebaseProject(cwd: string): boolean;
+/**
+ * Detecta se o projeto tem Firebase Cloud Functions
+ */
+declare function hasFirebaseFunctions(cwd: string): boolean;
+/**
+ * Verifica se um arquivo é uma Cloud Function exportada no index.ts
+ */
+declare function isExportedCloudFunction(filePath: string, cwd: string): boolean;
+/**
+ * Filtra arquivos órfãos removendo falsos positivos de Cloud Functions
+ *
+ * @param files - Lista de arquivos marcados como órfãos pelo Knip
+ * @param cwd - Diretório do projeto
+ * @returns Lista filtrada sem os falsos positivos
+ */
+declare function filterCloudFunctionsFalsePositives(files: string[], cwd: string): {
+    filtered: string[];
+    excluded: string[];
+};
+/**
+ * Limpa o cache (útil para testes ou quando o index.ts muda)
+ */
+declare function clearFirebaseCache(): void;
+
 /**
  * Obtém o caminho da pasta de cache
  */
@@ -254,6 +300,6 @@ declare function invalidateCache(cwd: string): void;
  * ```
  */
 
-declare const VERSION = "0.3.0";
+declare const VERSION = "0.3.2";
 
-export { type CommandOptions, type ContextOptions, type ContextResult, type DeadFile, type DeadOptions, type DeadResult, type FileCategory, type FileInfo, type FolderStats, type FunctionInfo, type ImpactFile, type ImpactOptions, type ImpactResult, type ImportInfo, type MapOptions, type MapResult, type OutputFormat, type ParamInfo, type RiskInfo, type SuggestOptions, type SuggestResult, type Suggestion, type SuggestionPriority, type TypeInfo, type TypeKind, VERSION, categoryIcons, context, dead, deadFix, detectCategory, getCacheDir, impact, invalidateCache, isCacheValid, isCodeFile, isEntryPoint, map, suggest };
+export { type CommandOptions, type ContextOptions, type ContextResult, type DeadFile, type DeadOptions, type DeadResult, type FileCategory, type FileInfo, type FolderStats, type FunctionInfo, type ImpactFile, type ImpactOptions, type ImpactResult, type ImportInfo, type MapOptions, type MapResult, type OutputFormat, type ParamInfo, type RiskInfo, type SuggestOptions, type SuggestResult, type Suggestion, type SuggestionPriority, type TypeInfo, type TypeKind, VERSION, categoryIcons, clearFirebaseCache, context, dead, deadFix, detectCategory, filterCloudFunctionsFalsePositives, getCacheDir, hasFirebaseFunctions, impact, invalidateCache, isCacheValid, isCodeFile, isEntryPoint, isExportedCloudFunction, isFirebaseProject, map, suggest };

package/dist/index.js

@@ -1,32 +1,42 @@
 import {
   VERSION,
   categoryIcons,
+  clearFirebaseCache,
   context,
   dead,
   deadFix,
   detectCategory,
+  filterCloudFunctionsFalsePositives,
   getCacheDir,
+  hasFirebaseFunctions,
   impact,
   invalidateCache,
   isCacheValid,
   isCodeFile,
   isEntryPoint,
+  isExportedCloudFunction,
+  isFirebaseProject,
   map,
   suggest
-} from "./chunk-BIT47QXF.js";
+} from "./chunk-EONUMGCN.js";
 export {
   VERSION,
   categoryIcons,
+  clearFirebaseCache,
   context,
   dead,
   deadFix,
   detectCategory,
+  filterCloudFunctionsFalsePositives,
   getCacheDir,
+  hasFirebaseFunctions,
   impact,
   invalidateCache,
   isCacheValid,
   isCodeFile,
   isEntryPoint,
+  isExportedCloudFunction,
+  isFirebaseProject,
   map,
   suggest
 };

package/dist/{server-OAPPO22L.js → server-K55EXKYX.js}

@@ -5,7 +5,7 @@ import {
   impact,
   map,
   suggest
-} from "./chunk-BIT47QXF.js";
+} from "./chunk-EONUMGCN.js";
 
 // src/mcp/server.ts
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@justmpm/ai-tool",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Ferramenta de análise de dependências e impacto para projetos TypeScript/JavaScript. Usa Skott + Knip internamente.",
   "keywords": [
     "dependency-analysis",