@justmpm/ai-tool 0.8.2 → 0.9.1

package/dist/cli.js

@@ -1,4 +1,7 @@
 #!/usr/bin/env node
+import {
+  describe
+} from "./chunk-CACALWH5.js";
 import {
   VERSION,
   area,
@@ -13,7 +16,7 @@ import {
   impact,
   map,
   suggest
-} from "./chunk-OMEBMR2V.js";
+} from "./chunk-NVJXCSJF.js";
 
 // src/cli.ts
 import { resolve } from "path";
@@ -30,6 +33,7 @@ COMANDOS:
   context <arquivo>      Extrai assinaturas de um arquivo (funcoes, tipos)
   context --area=<nome>  Contexto consolidado de toda uma area
   find <termo>           Busca simbolos no codigo (funcoes, tipos, etc)
+  describe <termo>       Busca areas por descricao em linguagem natural
 
 AREAS:
   areas                  Lista todas as areas/dominios do projeto
@@ -83,6 +87,7 @@ EXEMPLOS:
   ai-tool find useAuth             # Busca definicao e usos
   ai-tool find User --type=type    # Busca apenas tipos
   ai-tool find login --area=auth   # Busca na area auth
+  ai-tool describe cache           # Busca areas por descricao
   ai-tool areas
   ai-tool area auth
   ai-tool area auth --type=hook
@@ -108,7 +113,7 @@ async function main() {
     }
   }
   if (flags.mcp) {
-    const { startMcpServer } = await import("./server-JLK3OH5F.js");
+    const { startMcpServer } = await import("./server-OMKVOYK7.js");
     await startMcpServer();
     return;
   }
@@ -222,6 +227,15 @@ async function main() {
           trigger: flags.trigger
         });
         break;
+      case "describe":
+        if (!target) {
+          console.error("\u274C Erro: termo de busca \xE9 obrigat\xF3rio para o comando describe");
+          console.error("   Exemplo: ai-tool describe cache");
+          console.error("   Exemplo: ai-tool describe login");
+          process.exit(1);
+        }
+        result = await describe(target, { format, cwd });
+        break;
       default:
         console.error(`\u274C Comando desconhecido: ${command}`);
         console.error("   Use 'ai-tool --help' para ver comandos dispon\xEDveis.");

package/dist/index.d.ts

@@ -103,6 +103,16 @@ interface ImpactResult {
     };
     risks: RiskInfo[];
     suggestions: string[];
+    gitHistory?: {
+        hasGitRepo: boolean;
+        recentCommits: Array<{
+            hash: string;
+            shortHash: string;
+            message: string;
+            date: string;
+            author: string;
+        }>;
+    };
 }
 interface SuggestOptions extends CommandOptions {
     limit?: number;
@@ -120,6 +130,7 @@ interface SuggestResult {
     target: string;
     category: FileCategory;
     suggestions: Suggestion[];
+    testSuggestions: string[];
 }
 interface ContextOptions extends CommandOptions {
     depth?: number;
@@ -471,62 +482,99 @@ interface FindResult {
 declare function find(query: string, options?: FindOptions): Promise<string>;
 
 /**
- * Indexador de Projeto - Parseia todos os arquivos e extrai símbolos
+ * Detecção de Triggers Firebase
  *
- * Cria um índice completo do projeto que pode ser cacheado e reutilizado
- * pelos comandos find e context --area.
+ * Identifica e extrai informações de Cloud Functions v2 do Firebase
+ * (onCall, onDocumentCreated, onSchedule, etc) durante a indexação do projeto.
  */
 
 /**
  * Metadados de um trigger Firebase
  */
 interface TriggerInfo {
+    /** Tipo do trigger (ex: "onDocumentCreated", "onCall") */
     triggerType: string;
+    /** Path para Firestore/RTDB (ex: "users/{userId}") */
     triggerPath?: string;
+    /** Schedule expression para onSchedule (ex: "every 5 minutes") */
     triggerSchedule?: string;
 }
+
+/**
+ * Cache de Símbolos do Projeto
+ *
+ * Indexa todos os arquivos do projeto e extrai símbolos
+ * (funções, tipos, interfaces, enums, componentes, hooks, triggers Firebase)
+ *
+ * O índice resultante pode ser cacheado e reutilizado pelos comandos find e context.
+ */
+
 /**
  * Informação de um símbolo (função, tipo, constante, etc)
  */
 interface SymbolInfo {
+    /** Nome do símbolo */
     name: string;
+    /** Caminho do arquivo relativo ao projeto */
     file: string;
+    /** Número da linha onde o símbolo está definido */
     line: number;
+    /** Tipo do símbolo */
     kind: "function" | "type" | "interface" | "enum" | "const" | "component" | "hook" | "trigger";
+    /** Assinatura do símbolo */
     signature: string;
+    /** Se o símbolo é exportado */
     isExported: boolean;
+    /** Parâmetros da função (se aplicável) */
     params?: string[];
+    /** Tipo de retorno da função (se aplicável) */
     returnType?: string;
+    /** Definição completa (para tipos, interfaces, enums) */
     definition?: string;
+    /** Metadados específicos para triggers Firebase */
     triggerInfo?: TriggerInfo;
 }
 /**
  * Informação de import
  */
 interface ImportInfo {
+    /** Caminho do módulo importado */
     source: string;
+    /** Especificadores importados */
     specifiers: string[];
+    /** Se é um import type-only */
     isTypeOnly: boolean;
 }
 /**
  * Dados extraídos de um arquivo
  */
 interface FileSymbols {
+    /** Caminho do arquivo relativo ao projeto */
     path: string;
+    /** Categoria do arquivo (component, page, hook, etc) */
     category: FileCategory;
+    /** Lista de símbolos encontrados no arquivo */
     symbols: SymbolInfo[];
+    /** Lista de imports do arquivo */
     imports: ImportInfo[];
+    /** Lista de exports do arquivo */
     exports: string[];
 }
 /**
  * Índice completo do projeto
  */
 interface ProjectIndex {
+    /** Versão do formato do índice */
     version: string;
+    /** Timestamp de quando o índice foi criado */
     timestamp: string;
+    /** Mapa de caminho → dados do arquivo */
     files: Record<string, FileSymbols>;
+    /** Índice para busca rápida por nome do símbolo */
     symbolsByName: Record<string, SymbolInfo[]>;
+    /** Número total de arquivos indexados */
     fileCount: number;
+    /** Número total de símbolos encontrados */
     symbolCount: number;
 }
 

package/dist/index.js

@@ -44,7 +44,7 @@ import {
   setFileDescription,
   suggest,
   writeConfig
-} from "./chunk-OMEBMR2V.js";
+} from "./chunk-NVJXCSJF.js";
 export {
   COMMAND_REFERENCE,
   VERSION,

package/dist/server-OMKVOYK7.js

@@ -0,0 +1,511 @@
+import {
+  describe
+} from "./chunk-CACALWH5.js";
+import {
+  VERSION,
+  area,
+  areaContext,
+  areas,
+  areasInit,
+  context,
+  dead,
+  find,
+  functions,
+  impact,
+  map,
+  suggest
+} from "./chunk-NVJXCSJF.js";
+
+// src/mcp/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/mcp/tools.ts
+import { z } from "zod";
+function registerAllTools(server2) {
+  server2.registerTool(
+    "aitool_project_map",
+    {
+      title: "Project Map",
+      description: `Mapeia projeto e retorna resumo: contagens por categoria, areas detectadas, alertas.
+Use no inicio da sessao. Para detalhes: area_detail, file_context, suggest_reads.
+
+Parametros:
+- format: text (legivel) ou json (estruturado)
+- cwd: Diretorio do projeto a analisar`,
+      inputSchema: {
+        format: z.enum(["text", "json"]).default("text").describe("Formato de saida: text (legivel) ou json (estruturado)"),
+        cwd: z.string().optional().describe("Diretorio do projeto a analisar")
+      },
+      annotations: {
+        title: "Project Map",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      try {
+        const result = await map({
+          format: params.format,
+          cwd: params.cwd,
+          full: false
+        });
+        return { content: [{ type: "text", text: result }] };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Erro ao executar map: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "aitool_dead_code",
+    {
+      title: "Dead Code Detector",
+      description: `Detecta codigo morto: arquivos orfaos, exports nao usados, deps npm mortas.
+Use antes de refatoracoes ou periodicamente para limpeza.
+
+Parametros:
+- format: text (legivel) ou json (estruturado)
+- cwd: Diretorio do projeto a analisar`,
+      inputSchema: {
+        format: z.enum(["text", "json"]).default("text").describe("Formato de saida: text (legivel) ou json (estruturado)"),
+        cwd: z.string().optional().describe("Diretorio do projeto a analisar")
+      },
+      annotations: {
+        title: "Dead Code Detector",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      try {
+        const result = await dead({
+          format: params.format,
+          cwd: params.cwd
+        });
+        return { content: [{ type: "text", text: result }] };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Erro ao executar dead: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "aitool_impact_analysis",
+    {
+      title: "Impact Analysis",
+      description: `Analisa impacto de modificar um arquivo: upstream (quem importa), downstream (o que importa), riscos.
+Use ANTES de editar arquivos para planejar mudancas seguras.
+
+Parametros:
+- target: Arquivo a analisar (caminho completo, parcial ou nome)
+- format: text (legivel) ou json (estruturado)
+- cwd: Diretorio do projeto a analisar`,
+      inputSchema: {
+        target: z.string().min(1).describe("Arquivo a analisar: caminho completo, parcial ou nome do arquivo"),
+        format: z.enum(["text", "json"]).default("text").describe("Formato de saida: text (legivel) ou json (estruturado)"),
+        cwd: z.string().optional().describe("Diretorio do projeto a analisar")
+      },
+      annotations: {
+        title: "Impact Analysis",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      try {
+        const result = await impact(params.target, {
+          format: params.format,
+          cwd: params.cwd
+        });
+        return { content: [{ type: "text", text: result }] };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Erro ao executar impact: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "aitool_suggest_reads",
+    {
+      title: "Suggest Files to Read",
+      description: `Sugere arquivos para ler ANTES de modificar um arquivo.
+Prioriza: tipos usados, dependencias diretas, upstream, testes.
+
+Parametros:
+- target: Arquivo que sera modificado (caminho completo, parcial ou nome)
+- limit: Numero maximo de sugestoes (default: 10, max: 50)`,
+      inputSchema: {
+        target: z.string().min(1).describe("Arquivo que sera modificado: caminho completo, parcial ou nome"),
+        limit: z.number().int().min(1).max(50).default(10).describe("Numero maximo de sugestoes (default: 10, max: 50)"),
+        cwd: z.string().optional().describe("Diretorio do projeto a analisar")
+      },
+      annotations: {
+        title: "Suggest Files to Read",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      try {
+        const result = await suggest(params.target, {
+          limit: params.limit,
+          cwd: params.cwd,
+          format: "text"
+        });
+        return { content: [{ type: "text", text: result }] };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Erro ao executar suggest: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "aitool_file_context",
+    {
+      title: "Extract File Context",
+      description: `Extrai assinaturas de funcoes e tipos de um arquivo (sem implementacao).
+Use para entender a API publica antes de usar ou modificar.
+
+Parametros:
+- target: Arquivo para extrair contexto (caminho completo, parcial ou nome)
+- cwd: Diretorio do projeto a analisar`,
+      inputSchema: {
+        target: z.string().min(1).describe("Arquivo para extrair contexto: caminho completo, parcial ou nome"),
+        cwd: z.string().optional().describe("Diretorio do projeto a analisar")
+      },
+      annotations: {
+        title: "Extract File Context",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      try {
+        const result = await context(params.target, {
+          cwd: params.cwd,
+          format: "text"
+        });
+        return { content: [{ type: "text", text: result }] };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Erro ao executar context: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "aitool_list_areas",
+    {
+      title: "List Project Areas",
+      description: `Lista areas/dominios funcionais do projeto (auth, pets, stripe...).
+Diferente de categorias (hook, component). Use area_detail para ver arquivos.
+
+Parametros:
+- format: text (legivel) ou json (estruturado)
+- cwd: Diretorio do projeto a analisar`,
+      inputSchema: {
+        format: z.enum(["text", "json"]).default("text").describe("Formato de saida: text (legivel) ou json (estruturado)"),
+        cwd: z.string().optional().describe("Diretorio do projeto a analisar")
+      },
+      annotations: {
+        title: "List Project Areas",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      try {
+        const result = await areas({
+          format: params.format,
+          cwd: params.cwd
+        });
+        return { content: [{ type: "text", text: result }] };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Erro ao executar areas: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "aitool_area_detail",
+    {
+      title: "Area Detail",
+      description: `Mostra arquivos de uma area especifica, agrupados por categoria.
+Use ID (ex: auth) ou Name (ex: Autentica\xE7\xE3o) para identificar a area.
+
+Parametros:
+- target: Nome da area (ex: auth, dashboard, billing)
+- type: Filtrar por categoria (page, component, hook, service, etc)
+- full: Mostrar todos os arquivos (default: resumido)
+- cwd: Diretorio do projeto a analisar`,
+      inputSchema: {
+        target: z.string().min(1).describe("Nome da area: auth, dashboard, billing, etc"),
+        type: z.enum(["page", "layout", "route", "component", "hook", "service", "store", "util", "type", "config", "test", "other"]).optional().describe("Filtrar por categoria especifica"),
+        full: z.boolean().default(false).describe("Mostrar todos os arquivos (default: resumido)"),
+        cwd: z.string().optional().describe("Diretorio do projeto a analisar")
+      },
+      annotations: {
+        title: "Area Detail",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      try {
+        const result = await area(params.target, {
+          type: params.type,
+          full: params.full,
+          cwd: params.cwd,
+          format: "text"
+        });
+        return { content: [{ type: "text", text: result }] };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Erro ao executar area: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "aitool_areas_init",
+    {
+      title: "Initialize Areas Config",
+      description: `Gera .analyze/areas.config.json para customizar deteccao de areas.
+Use quando houver arquivos sem area ou precisar ajustar deteccao.
+
+Parametros:
+- force: Sobrescrever config existente
+- cwd: Diretorio do projeto`,
+      inputSchema: {
+        force: z.boolean().default(false).describe("Sobrescrever config existente"),
+        cwd: z.string().optional().describe("Diretorio do projeto")
+      },
+      annotations: {
+        title: "Initialize Areas Config",
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: false,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      try {
+        const result = await areasInit({
+          force: params.force,
+          cwd: params.cwd
+        });
+        return { content: [{ type: "text", text: result }] };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Erro ao executar areas init: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "aitool_find",
+    {
+      title: "Find Symbol",
+      description: `Busca simbolos no codigo: funcoes, tipos, componentes, hooks, constantes.
+Retorna definicao + referencias/usos. Diferente de grep, entende o AST do TypeScript.
+
+Parametros:
+- query: Termo a buscar (ex: useAuth, User, login)
+- type: Filtrar por tipo (function, type, const, component, hook, trigger, all)
+- area: Buscar apenas em uma area especifica (ex: auth, dashboard)
+- def: Mostrar apenas definicoes (onde e declarado)
+- refs: Mostrar apenas referencias/usos`,
+      inputSchema: {
+        query: z.string().min(1).describe("Termo a buscar (nome de funcao, tipo, componente, etc)"),
+        type: z.enum(["function", "type", "const", "component", "hook", "trigger", "all"]).default("all").describe("Filtrar por tipo de simbolo (use trigger para Cloud Functions)"),
+        area: z.string().optional().describe("Filtrar busca por area especifica (ex: auth, dashboard)"),
+        def: z.boolean().default(false).describe("Mostrar apenas definicoes (onde e declarado)"),
+        refs: z.boolean().default(false).describe("Mostrar apenas referencias (onde e usado)"),
+        cwd: z.string().optional().describe("Diretorio do projeto a analisar")
+      },
+      annotations: {
+        title: "Find Symbol",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      try {
+        const result = await find(params.query, {
+          type: params.type,
+          area: params.area,
+          def: params.def,
+          refs: params.refs,
+          cwd: params.cwd,
+          format: "text"
+        });
+        return { content: [{ type: "text", text: result }] };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Erro ao executar find: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "aitool_area_context",
+    {
+      title: "Area Context",
+      description: `Contexto consolidado de toda uma area: tipos, hooks, funcoes, componentes, services, stores.
+Uma chamada = entender toda a feature. Muito mais eficiente que chamar context em cada arquivo.
+
+Parametros:
+- area: Nome da area (ex: auth, dashboard, payments)
+- cwd: Diretorio do projeto a analisar`,
+      inputSchema: {
+        area: z.string().min(1).describe("Nome da area: auth, dashboard, payments, etc"),
+        cwd: z.string().optional().describe("Diretorio do projeto a analisar")
+      },
+      annotations: {
+        title: "Area Context",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      try {
+        const result = await areaContext(params.area, {
+          cwd: params.cwd,
+          format: "text"
+        });
+        return { content: [{ type: "text", text: result }] };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Erro ao executar area context: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "aitool_list_functions",
+    {
+      title: "List Cloud Functions",
+      description: `Lista todas as Cloud Functions Firebase do projeto.
+Agrupa por tipo de trigger (onCall, onDocumentCreated, onSchedule, etc).
+Use para entender a arquitetura serverless antes de modificar triggers.
+
+Parametros:
+- trigger: Filtrar por tipo de trigger (ex: onCall, onDocumentCreated, onSchedule)
+- format: text (legivel) ou json (estruturado)`,
+      inputSchema: {
+        trigger: z.string().optional().describe("Filtrar por tipo de trigger (ex: onCall, onDocumentCreated, onSchedule)"),
+        format: z.enum(["text", "json"]).default("text").describe("Formato de saida: text (legivel) ou json (estruturado)"),
+        cwd: z.string().optional().describe("Diretorio do projeto a analisar")
+      },
+      annotations: {
+        title: "List Cloud Functions",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      try {
+        const result = await functions({
+          format: params.format,
+          trigger: params.trigger,
+          cwd: params.cwd
+        });
+        return { content: [{ type: "text", text: result }] };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Erro ao executar functions: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+  server2.registerTool(
+    "aitool_describe",
+    {
+      title: "Search by Description",
+      description: `Busca \xE1reas por descri\xE7\xE3o em linguagem natural.
+Ex: "Onde implementou login?" \u2192 encontra \xE1rea de autentica\xE7\xE3o.
+
+Parametros:
+- query: Descri\xE7\xE3o ou keyword
+- cwd: Diretorio do projeto`,
+      inputSchema: {
+        query: z.string().min(1).describe("Descri\xE7\xE3o ou keyword para buscar \xE1reas"),
+        format: z.enum(["text", "json"]).default("text").describe("Formato de saida: text (legivel) ou json (estruturado)"),
+        cwd: z.string().optional().describe("Diretorio do projeto a analisar")
+      },
+      annotations: {
+        title: "Search by Description",
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false
+      }
+    },
+    async (params) => {
+      try {
+        const result = await describe(params.query, {
+          format: params.format,
+          cwd: params.cwd
+        });
+        return { content: [{ type: "text", text: result }] };
+      } catch (error) {
+        return {
+          content: [{ type: "text", text: `Erro ao executar describe: ${error instanceof Error ? error.message : String(error)}` }],
+          isError: true
+        };
+      }
+    }
+  );
+}
+
+// src/mcp/server.ts
+var server = new McpServer({
+  name: "ai-tool-mcp-server",
+  version: VERSION
+});
+registerAllTools(server);
+async function startMcpServer() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error(`[ai-tool] MCP server v${VERSION} running via stdio`);
+}
+export {
+  startMcpServer
+};