@justmpm/ai-tool 0.8.1 → 0.9.0

package/dist/server-L24EN4AN.js

@@ -0,0 +1,649 @@
+import {
+  VERSION,
+  area,
+  areaContext,
+  areas,
+  areasInit,
+  context,
+  dead,
+  find,
+  findSimilar,
+  formatOutput,
+  functions,
+  impact,
+  map,
+  parseCommandOptions,
+  readConfig,
+  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";
+
+// src/commands/describe.ts
+async function describe(query, options = {}) {
+  const { cwd, format } = parseCommandOptions(options);
+  if (!query || query.trim().length === 0) {
+    throw new Error("Query \xE9 obrigat\xF3ria. Exemplo: ai-tool describe 'autentica\xE7\xE3o'");
+  }
+  try {
+    const config = readConfig(cwd);
+    const normalizedQuery = query.toLowerCase().trim();
+    const candidates = Object.entries(config.areas).map(([id, area2]) => ({
+      id,
+      name: area2.name,
+      description: area2.description || ""
+    }));
+    const matches = findAreaMatches(normalizedQuery, candidates, config);
+    const suggestions = [];
+    if (matches.length === 0) {
+      const similarAreaIds = findSimilar(
+        normalizedQuery,
+        candidates.map((c) => c.id),
+        { maxDistance: 2, limit: 3 }
+      );
+      const similarNames = findSimilar(
+        normalizedQuery,
+        candidates.map((c) => c.name),
+        { maxDistance: 2, limit: 3 }
+      );
+      suggestions.push(
+        ...similarAreaIds.map((id) => `\u2192 ai-tool describe ${id}`),
+        ...similarNames.map((name) => `\u2192 ai-tool describe "${name}"`)
+      );
+    }
+    const result = {
+      version: "1.0.0",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      query,
+      areas: matches,
+      suggestions: suggestions.length > 0 ? suggestions : void 0
+    };
+    return formatOutput(result, format, formatDescribeText);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(`Erro ao executar describe: ${message}`);
+  }
+}
+function findAreaMatches(normalizedQuery, candidates, config) {
+  const matches = [];
+  for (const candidate of candidates) {
+    const searchableText = `${candidate.id} ${candidate.name} ${candidate.description}`.toLowerCase();
+    const hasDirectMatch = searchableText.includes(normalizedQuery);
+    const queryWords = normalizedQuery.split(/\s+/);
+    const allWordsMatch = queryWords.every((word) => searchableText.includes(word));
+    if (hasDirectMatch || allWordsMatch) {
+      const areaFiles = getAreaFiles(candidate.id, config);
+      const score = calculateRelevanceScore(normalizedQuery, searchableText);
+      matches.push({
+        id: candidate.id,
+        name: candidate.name,
+        description: candidate.description || "Sem descri\xE7\xE3o",
+        files: areaFiles,
+        fileCount: areaFiles.length,
+        score
+      });
+    }
+  }
+  return matches.sort((a, b) => a.score - b.score);
+}
+function getAreaFiles(areaId, config) {
+  const files = [];
+  const areaConfig = config.areas[areaId];
+  if (areaConfig?.patterns) {
+    files.push(`[Use 'ai-tool area ${areaId}' para ver arquivos completos]`);
+  }
+  return files;
+}
+function calculateRelevanceScore(query, text) {
+  if (text.includes(query)) {
+    return 0;
+  }
+  const queryWords = query.split(/\s+/).filter(Boolean);
+  const allWordsPresent = queryWords.every((word) => text.includes(word));
+  if (allWordsPresent) {
+    return 1;
+  }
+  return 10;
+}
+function formatDescribeText(result) {
+  let out = "";
+  if (result.areas.length === 0) {
+    out += `\u274C Nenhuma \xE1rea encontrada para: "${result.query}"
+
+`;
+    if (result.suggestions && result.suggestions.length > 0) {
+      out += `\u{1F4A1} Voc\xEA quis dizer?
+`;
+      for (const suggestion of result.suggestions) {
+        out += `   ${suggestion}
+`;
+      }
+      out += `
+`;
+    }
+    out += `\u{1F4D6} Dica: Use 'ai-tool areas' para listar todas as \xE1reas dispon\xEDveis`;
+    return out;
+  }
+  out += `\u{1F50D} Busca: "${result.query}"
+
+`;
+  for (const area2 of result.areas) {
+    out += `## ${area2.name} (${area2.id})
+`;
+    out += `${area2.description}
+`;
+    out += `\u{1F4C1} ${area2.fileCount} arquivo(s)
+
+`;
+    if (area2.files.length > 0) {
+      out += `Arquivos:
+`;
+      for (const file of area2.files) {
+        out += `   \u2022 ${file}
+`;
+      }
+      out += "\n";
+    }
+  }
+  out += `\u{1F4D6} Pr\xF3ximos passos:
+`;
+  out += `   \u2192 ai-tool area <id> - ver detalhes de uma \xE1rea
+`;
+  out += `   \u2192 ai-tool context --area=<id> - contexto completo de uma \xE1rea
+`;
+  return out;
+}
+
+// src/mcp/tools.ts
+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
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@justmpm/ai-tool",
-  "version": "0.8.1",
-  "description": "Ferramenta de análise de dependências e impacto para projetos TypeScript/JavaScript. Usa Skott + Knip internamente.",
+  "version": "0.9.0",
+  "description": "Ferramenta de análise de dependências e impacto para projetos TypeScript/JavaScript. Usa Skott + Knip internamente. Inclui busca por descrição, integração Git e testes inteligentes.",
   "keywords": [
     "dependency-analysis",
     "impact-analysis",