@justmpm/ai-tool 0.5.4 → 0.6.0

package/README.md

@@ -103,6 +103,7 @@ Extrai assinaturas de funcoes e tipos SEM a implementacao.
 ```bash
 ai-tool context Button
 ai-tool context src/hooks/useAuth.ts --format=json
+ai-tool context --area=auth   # Contexto consolidado de toda uma area
 ```
 
 **Extrai:**
@@ -113,6 +114,36 @@ ai-tool context src/hooks/useAuth.ts --format=json
 
 Ideal para entender rapidamente a API publica de um arquivo.
 
+**Contexto de Area** (`--area=<nome>`):
+- Tipos e interfaces da area
+- Hooks com parametros e retornos
+- Funcoes principais
+- Componentes React
+- Services e stores
+- Uma chamada = entender toda a feature
+
+### `find` - Busca de Simbolos
+
+Busca simbolos no codigo (funcoes, tipos, componentes, hooks, constantes).
+
+```bash
+ai-tool find useAuth              # Definicao + usos
+ai-tool find User --type=type     # Busca apenas tipos
+ai-tool find login --area=auth    # Busca na area auth
+ai-tool find submit --def         # Apenas definicoes
+ai-tool find submit --refs        # Apenas referencias/usos
+```
+
+**Tipos de simbolos:**
+- `function` - Funcoes e arrow functions
+- `type` - Types, interfaces e enums
+- `const` - Constantes e variaveis
+- `component` - Componentes React (funcao que retorna JSX)
+- `hook` - React hooks (funcao que comeca com `use`)
+- `all` - Todos os tipos (default)
+
+**Diferente de grep:** Entende o AST do TypeScript, encontra definicoes reais e onde sao usados.
+
 ### `areas` - Areas/Dominios Funcionais
 
 Lista todas as areas funcionais do projeto (auth, dashboard, stripe, etc).
@@ -205,14 +236,16 @@ 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
-- `aitool_list_areas` - Lista areas funcionais
-- `aitool_area_detail` - Detalhe de uma area
+- `aitool_project_map` - Mapa do projeto (resumo compacto)
+- `aitool_dead_code` - Detecta codigo morto
+- `aitool_impact_analysis` - Analise de impacto antes de modificar
+- `aitool_suggest_reads` - Sugere arquivos para ler antes de editar
+- `aitool_file_context` - Extrai assinaturas de um arquivo
+- `aitool_list_areas` - Lista areas funcionais do projeto
+- `aitool_area_detail` - Arquivos de uma area especifica
 - `aitool_areas_init` - Gera config de areas
+- `aitool_area_context` - Contexto consolidado de toda uma area
+- `aitool_find` - Busca simbolos no codigo (definicao + usos)
 
 ### Configuracao Claude Code
 
@@ -250,7 +283,7 @@ Adicione ao `claude_desktop_config.json`:
 ## Uso Programatico
 
 ```typescript
-import { map, dead, impact, suggest, context, areas, area, areasInit } from "@justmpm/ai-tool";
+import { map, dead, impact, suggest, context, areaContext, find, areas, area, areasInit } from "@justmpm/ai-tool";
 
 // Mapa do projeto (resumo por padrao, full: true para lista completa)
 const projectMap = await map({ format: "json" });
@@ -268,6 +301,12 @@ const suggestions = await suggest("Button", { limit: 5 });
 // Contexto do arquivo
 const fileContext = await context("Button", { format: "json" });
 
+// Contexto de uma area inteira
+const authContext = await areaContext("auth", { format: "json" });
+
+// Busca de simbolos
+const symbolSearch = await find("useAuth", { type: "hook", area: "auth" });
+
 // Areas funcionais
 const projectAreas = await areas({ format: "json" });
 
@@ -288,7 +327,10 @@ await areasInit({ force: false });
 | `--full` | Lista completa (`map`: arquivos, `area`: todos) | `false` |
 | `--fix` | Remove codigo morto (so `dead`) | `false` |
 | `--limit=<n>` | Limite de sugestoes (so `suggest`) | `10` |
-| `--type=<cat>` | Filtra por categoria (so `area`) | - |
+| `--type=<cat>` | Filtra por categoria (`area`) ou tipo de simbolo (`find`) | - |
+| `--area=<nome>` | Filtra por area (`context`, `find`) | - |
+| `--def` | Mostra apenas definicoes (so `find`) | `false` |
+| `--refs` | Mostra apenas referencias/usos (so `find`) | `false` |
 | `--mcp` | Inicia servidor MCP | - |
 
 ## Categorias de Arquivos

package/dist/chunk-M7JM3XRW.js

@@ -0,0 +1,219 @@
+import {
+  cacheSymbolsIndex,
+  detectFileAreas,
+  formatFindText,
+  getCachedSymbolsIndex,
+  indexProject,
+  isCacheValid,
+  isFileIgnored,
+  readConfig,
+  updateCacheMeta
+} from "./chunk-UDT7TLSN.js";
+
+// 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";
+    case "type":
+      return kind === "type" || kind === "interface" || kind === "enum";
+    case "const":
+      return kind === "const";
+    case "component":
+      return kind === "component";
+    case "hook":
+      return kind === "hook";
+    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";
+    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";
+}
+
+export {
+  find
+};