@justmpm/supergrep 0.1.1 → 0.2.0

package/dist/{chunk-SENMQNTX.js → chunk-5PJJZ4CK.js}

@@ -6,9 +6,9 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z } from "zod";
 
 // src/tools/find.ts
-import { parse } from "@ast-grep/napi";
-import { readFile, readdir } from "fs/promises";
-import { join, relative, resolve, extname } from "path";
+import { findInFiles } from "@ast-grep/napi";
+import { relative, resolve } from "path";
+import { stat } from "fs/promises";
 
 // src/utils/lang.ts
 import { Lang } from "@ast-grep/napi";
@@ -65,35 +65,6 @@ function langName(lang) {
   };
   return friendly[langStr] ?? langStr;
 }
-function isSupportedExtension(filePath) {
-  const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
-  return SUPPORTED_EXTENSIONS.has(ext);
-}
-var IGNORED_EXTENSIONS_SUBSTRINGS = [
-  ".min.js",
-  ".min.css",
-  ".bundle.js",
-  ".chunk.js",
-  ".map",
-  ".d.ts"
-];
-function shouldIgnoreFile(filePath) {
-  const lower = filePath.toLowerCase();
-  for (const ext of IGNORED_EXTENSIONS_SUBSTRINGS) {
-    if (lower.includes(ext)) return true;
-  }
-  return false;
-}
-var IGNORED_DIRS = [
-  "node_modules",
-  "dist",
-  "build",
-  ".git",
-  ".next",
-  ".turbo",
-  "coverage",
-  "out"
-];
 
 // src/tools/find.ts
 var MULTI_META_RE = /\$\$\$([A-Z_][A-Z0-9_]*)/g;
@@ -102,33 +73,47 @@ async function findPattern(options) {
   const startTime = Date.now();
   const warnings = [];
   const cwd = options.cwd ?? process.cwd();
-  const lang = resolveLangForOptions(options, cwd, warnings);
-  if (!lang) {
+  let lang;
+  if (options.lang) {
+    lang = resolveLang(options.lang);
+    if (!lang) {
+      warnings.push(`Linguagem "${options.lang}" nao reconhecida. Usando autodeteccao...`);
+    }
+  }
+  const searchPath = resolve(cwd, options.path ?? ".");
+  try {
+    await stat(searchPath);
+  } catch {
+    warnings.push(`Path nao encontrado: ${searchPath}. Usando diretorio atual.`);
     throw new LanguageNotDetectedError(options.lang ?? "desconhecida");
   }
-  validatePattern(options.pattern, lang);
-  const searchDir = resolve(cwd, options.path ?? ".");
-  const files = await findCodeFiles(searchDir, cwd, lang);
-  warnings.push(...files.warnings);
   const metaVars = extractMetaVarInfo(options.pattern);
+  const napiConfig = {
+    rule: { pattern: options.pattern }
+  };
+  const findConfig = {
+    paths: [searchPath],
+    matcher: napiConfig
+  };
+  if (lang) {
+    findConfig.languageGlobs = langToGlobs(lang);
+  }
+  const langForSearch = lang ?? resolveLang("typescript");
   const matches = [];
-  for (const filePath of files.paths) {
-    try {
-      const source = await readFile(filePath, "utf-8");
-      const ast = parse(lang, source);
-      const root = ast.root();
-      const foundNodes = root.findAll(options.pattern);
-      for (const node of foundNodes) {
+  try {
+    const fileResults = await findInFilesWrapper(langForSearch, findConfig);
+    for (const { file, nodes } of fileResults) {
+      for (const node of nodes) {
         const range = node.range();
+        const text = node.text();
         const match = {
-          file: relative(cwd, filePath).replace(/\\/g, "/"),
+          file: relative(cwd, file).replace(/\\/g, "/"),
           line: range.start.line,
           column: range.start.column,
           endLine: range.end.line,
           endColumn: range.end.column,
-          text: node.text(),
-          metaVariables: {},
-          context: extractContextLines(source, range.start.line, 2)
+          text,
+          metaVariables: {}
         };
         for (const { name, isMulti } of metaVars) {
           if (isMulti) {
@@ -145,19 +130,23 @@ async function findPattern(options) {
         }
         matches.push(match);
       }
-    } catch {
-      continue;
     }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    if (lang) {
+      throw new PatternParseError(options.pattern, lang);
+    }
+    throw new Error(`Erro na busca: ${msg}`);
   }
-  const uniqueFiles = new Set(matches.map((m) => m.file));
+  const filesWithMatchesSet = new Set(matches.map((m) => m.file));
   const executionTimeMs = Date.now() - startTime;
   return {
     result: {
       pattern: options.pattern,
-      lang,
+      lang: langForSearch,
       matches,
-      filesScanned: files.paths.length,
-      filesWithMatches: uniqueFiles.size,
+      filesScanned: matches.length > 0 ? filesWithMatchesSet.size : 0,
+      filesWithMatches: filesWithMatchesSet.size,
       executionTimeMs
     },
     warnings
@@ -185,92 +174,56 @@ function extractMetaVarInfo(pattern) {
   }
   return result;
 }
-function extractContextLines(source, line, contextLines) {
-  const lines = source.split("\n");
-  const start = Math.max(0, line - contextLines);
-  const end = Math.min(lines.length, line + contextLines + 1);
-  return lines.slice(start, end);
-}
-function resolveLangForOptions(options, _cwd, warnings) {
-  if (options.lang) {
-    const lang = resolveLang(options.lang);
-    if (!lang) {
-      warnings.push(`Linguagem "${options.lang}" nao reconhecida. Tentando autodeteccao...`);
-    } else {
-      return lang;
-    }
-  }
-  if (options.path) {
-    const ext = extname(options.path).toLowerCase();
-    if (ext && isSupportedExtension(options.path)) {
-      const detected = detectLangFromFile(options.path);
-      if (detected) return detected;
-    }
-  }
-  return resolveLang("typescript");
+var IGNORED_DIR_PATTERNS = [
+  /[/\\]node_modules[/\\]/,
+  /[/\\]dist[/\\]/,
+  /[/\\]build[/\\]/,
+  /[/\\]\.git[/\\]/,
+  /[/\\]\.next[/\\]/,
+  /[/\\]\.turbo[/\\]/,
+  /[/\\]coverage[/\\]/,
+  /[/\\]out[/\\]/
+];
+function isIgnoredPath(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const wrapped = `/${normalized}/`;
+  return IGNORED_DIR_PATTERNS.some((re) => re.test(wrapped));
 }
-function validatePattern(pattern, lang) {
-  try {
-    parse(lang, pattern);
-  } catch {
-    try {
-      parse(lang, `const _x = ${pattern}`);
-    } catch {
-      throw new PatternParseError(pattern, lang);
+async function findInFilesWrapper(lang, config) {
+  const results = [];
+  let callbacksReceived = 0;
+  const totalFiles = await findInFiles(
+    lang,
+    config,
+    (err, nodes) => {
+      callbacksReceived++;
+      if (err || nodes.length === 0) return;
+      const file = nodes[0].getRoot()?.filename() ?? "unknown";
+      if (isIgnoredPath(file)) return;
+      results.push({ file, nodes });
     }
+  );
+  while (callbacksReceived < totalFiles) {
+    await new Promise((r) => setTimeout(r, 10));
   }
+  return results;
 }
-async function findCodeFiles(searchDir, _cwd, _lang) {
-  const warnings = [];
-  try {
-    const { stat: stat3 } = await import("fs/promises");
-    const dirStat = await stat3(searchDir);
-    if (dirStat.isFile()) {
-      if (!isSupportedExtension(searchDir)) {
-        const fileName = searchDir.split(/[/\\]/).pop() ?? searchDir;
-        warnings.push(
-          `Arquivo ${fileName}: extensao pode nao ser suportada para ${langName(_lang)}`
-        );
-      }
-      return { paths: [searchDir], warnings };
-    }
-  } catch {
-    warnings.push(`Path nao encontrado: ${searchDir}. Usando diretorio atual.`);
-    return { paths: [], warnings };
-  }
-  const paths = [];
-  async function walk(dir) {
-    try {
-      const entries = await readdir(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = join(dir, entry.name);
-        if (entry.isDirectory()) {
-          if (IGNORED_DIRS.includes(entry.name) || entry.name.startsWith(".")) {
-            continue;
-          }
-          await walk(fullPath);
-        } else if (entry.isFile()) {
-          if (shouldIgnoreFile(fullPath)) continue;
-          if (!isSupportedExtension(fullPath)) continue;
-          paths.push(fullPath);
-        }
-      }
-    } catch {
-    }
-  }
-  await walk(searchDir);
-  if (paths.length > 5e3) {
-    warnings.push(
-      `Muitos arquivos encontrados (${paths.length}). Limitando a 5000. Use --path para focar em um diretorio.`
-    );
-    return { paths: paths.slice(0, 5e3), warnings };
-  }
-  if (paths.length === 0) {
-    warnings.push(
-      `Nenhum arquivo de codigo encontrado em: ${relative(_cwd, searchDir)}`
-    );
+function langToGlobs(lang) {
+  const langStr = String(lang);
+  switch (langStr) {
+    case "TypeScript":
+      return ["*.ts"];
+    case "JavaScript":
+      return ["*.js", "*.jsx", "*.mjs", "*.cjs"];
+    case "Tsx":
+      return ["*.tsx"];
+    case "Css":
+      return ["*.css", "*.scss", "*.less"];
+    case "Html":
+      return ["*.html", "*.htm"];
+    default:
+      return [];
   }
-  return { paths, warnings };
 }
 var PatternParseError = class extends Error {
   pattern;
@@ -292,9 +245,9 @@ var LanguageNotDetectedError = class extends Error {
 };
 
 // src/tools/tree.ts
-import { parse as parse2 } from "@ast-grep/napi";
-import { readFile as readFile2, stat } from "fs/promises";
-import { resolve as resolve2, relative as relative2, extname as extname2 } from "path";
+import { parse } from "@ast-grep/napi";
+import { readFile, stat as stat2 } from "fs/promises";
+import { resolve as resolve2, relative as relative2, extname } from "path";
 async function exploreTree(options) {
   const warnings = [];
   const cwd = options.cwd ?? process.cwd();
@@ -315,11 +268,11 @@ async function exploreTree(options) {
   } else if (options.path) {
     filePath = resolve2(cwd, options.path);
     try {
-      await stat(filePath);
+      await stat2(filePath);
     } catch {
       throw new FileNotFoundError(filePath);
     }
-    source = await readFile2(filePath, "utf-8");
+    source = await readFile(filePath, "utf-8");
     if (options.lang) {
       detectedLang = resolveLang(options.lang);
       if (!detectedLang) {
@@ -330,7 +283,7 @@ async function exploreTree(options) {
       detectedLang = detectLangFromFile(filePath);
       if (!detectedLang) {
         warnings.push(
-          `Nao foi possivel detectar linguagem da extensao "${extname2(filePath)}". Usando TypeScript.`
+          `Nao foi possivel detectar linguagem da extensao "${extname(filePath)}". Usando TypeScript.`
         );
         detectedLang = resolveLang("typescript");
       }
@@ -341,7 +294,7 @@ async function exploreTree(options) {
   const lang = detectedLang;
   let ast;
   try {
-    ast = parse2(lang, source);
+    ast = parse(lang, source);
   } catch (parseErr) {
     const msg = parseErr instanceof Error ? parseErr.message : String(parseErr);
     throw new TreeParseError(filePath, lang, msg);
@@ -393,9 +346,9 @@ var TreeParseError = class extends Error {
 };
 
 // src/tools/replace.ts
-import { parse as parse3 } from "@ast-grep/napi";
-import { readFile as readFile3, readdir as readdir2, stat as stat2 } from "fs/promises";
-import { join as join2, resolve as resolve3, relative as relative3 } from "path";
+import { findInFiles as findInFiles2 } from "@ast-grep/napi";
+import { resolve as resolve3, relative as relative3 } from "path";
+import { stat as stat3 } from "fs/promises";
 var MULTI_META_RE2 = /\$\$\$([A-Z_][A-Z0-9_]*)/g;
 var SINGLE_META_RE2 = /(?<!\$)\$(?:\$\$)?([A-Z_][A-Z0-9_]*)/g;
 async function replacePreview(options) {
@@ -418,18 +371,28 @@ async function replacePreview(options) {
   } else {
     lang = resolveLang("typescript");
   }
-  validateReplacePattern(options.pattern, lang);
-  const searchDir = resolve3(cwd, options.path ?? ".");
-  const files = await findCodeFiles2(searchDir);
+  const searchPath = resolve3(cwd, options.path ?? ".");
+  try {
+    await stat3(searchPath);
+  } catch {
+    throw new ReplaceLangError(
+      `Path nao encontrado: ${searchPath}`
+    );
+  }
   const metaVars = extractMetaVarInfo2(options.pattern);
+  const napiConfig = {
+    rule: { pattern: options.pattern }
+  };
+  const findConfig = {
+    paths: [searchPath],
+    matcher: napiConfig,
+    languageGlobs: langToGlobs2(lang)
+  };
   const changes = [];
-  for (const filePath of files.paths) {
-    try {
-      const source = await readFile3(filePath, "utf-8");
-      const ast = parse3(lang, source);
-      const root = ast.root();
-      const foundNodes = root.findAll(options.pattern);
-      for (const node of foundNodes) {
+  try {
+    const fileResults = await findInFilesWrapper2(lang, findConfig);
+    for (const { file, nodes } of fileResults) {
+      for (const node of nodes) {
         const metaVarValues = {};
         for (const { name, isMulti } of metaVars) {
           if (isMulti) {
@@ -453,16 +416,16 @@ async function replacePreview(options) {
         }
         const range = node.range();
         changes.push({
-          file: relative3(cwd, filePath).replace(/\\/g, "/"),
+          file: relative3(cwd, file).replace(/\\/g, "/"),
           line: range.start.line,
           column: range.start.column,
           original: node.text(),
           replacement: interpolated
         });
       }
-    } catch {
-      continue;
     }
+  } catch {
+    throw new ReplacePatternError(options.pattern, lang);
   }
   const uniqueFiles = new Set(changes.map((c) => c.file));
   return {
@@ -471,7 +434,7 @@ async function replacePreview(options) {
       rewrite: options.rewrite,
       lang,
       changes,
-      filesScanned: files.paths.length,
+      filesScanned: changes.length > 0 ? uniqueFiles.size : 0,
       filesAffected: uniqueFiles.size
     },
     warnings
@@ -499,55 +462,56 @@ function extractMetaVarInfo2(pattern) {
   }
   return result;
 }
-function validateReplacePattern(pattern, lang) {
-  try {
-    parse3(lang, pattern);
-  } catch {
-    try {
-      parse3(lang, `const _x = ${pattern}`);
-    } catch {
-      throw new ReplacePatternError(pattern, lang);
-    }
-  }
+var IGNORED_DIR_PATTERNS2 = [
+  /[/\\]node_modules[/\\]/,
+  /[/\\]dist[/\\]/,
+  /[/\\]build[/\\]/,
+  /[/\\]\.git[/\\]/,
+  /[/\\]\.next[/\\]/,
+  /[/\\]\.turbo[/\\]/,
+  /[/\\]coverage[/\\]/,
+  /[/\\]out[/\\]/
+];
+function isIgnoredPath2(filePath) {
+  const normalized = filePath.replace(/\\/g, "/");
+  const wrapped = `/${normalized}/`;
+  return IGNORED_DIR_PATTERNS2.some((re) => re.test(wrapped));
 }
-async function findCodeFiles2(searchDir) {
-  const warnings = [];
-  try {
-    const dirStat = await stat2(searchDir);
-    if (dirStat.isFile()) {
-      return { paths: [searchDir], warnings };
-    }
-  } catch {
-    return { paths: [], warnings };
-  }
-  const paths = [];
-  async function walk(dir) {
-    try {
-      const entries = await readdir2(dir, { withFileTypes: true });
-      for (const entry of entries) {
-        const fullPath = join2(dir, entry.name);
-        if (entry.isDirectory()) {
-          if (IGNORED_DIRS.includes(entry.name) || entry.name.startsWith(".")) {
-            continue;
-          }
-          await walk(fullPath);
-        } else if (entry.isFile()) {
-          if (shouldIgnoreFile(fullPath)) continue;
-          if (!isSupportedExtension(fullPath)) continue;
-          paths.push(fullPath);
-        }
-      }
-    } catch {
+async function findInFilesWrapper2(lang, config) {
+  const results = [];
+  let callbacksReceived = 0;
+  const totalFiles = await findInFiles2(
+    lang,
+    config,
+    (err, nodes) => {
+      callbacksReceived++;
+      if (err || nodes.length === 0) return;
+      const file = nodes[0].getRoot()?.filename() ?? "unknown";
+      if (isIgnoredPath2(file)) return;
+      results.push({ file, nodes });
     }
+  );
+  while (callbacksReceived < totalFiles) {
+    await new Promise((r) => setTimeout(r, 10));
   }
-  await walk(searchDir);
-  if (paths.length > 5e3) {
-    warnings.push(
-      `Muitos arquivos (${paths.length}). Limitando a 5000. Use --path para focar.`
-    );
-    return { paths: paths.slice(0, 5e3), warnings };
+  return results;
+}
+function langToGlobs2(lang) {
+  const langStr = String(lang);
+  switch (langStr) {
+    case "TypeScript":
+      return ["*.ts"];
+    case "JavaScript":
+      return ["*.js", "*.jsx", "*.mjs", "*.cjs"];
+    case "Tsx":
+      return ["*.tsx"];
+    case "Css":
+      return ["*.css", "*.scss", "*.less"];
+    case "Html":
+      return ["*.html", "*.htm"];
+    default:
+      return [];
   }
-  return { paths, warnings };
 }
 var ReplacePatternError = class extends Error {
   pattern;
@@ -1052,10 +1016,18 @@ metavariaveis ($VAR, $$VAR, $$$VARS) como curingas que capturam partes dinamicas
 \u{1F4E6} LINGUAGENS SUPORTADAS (apenas 5):
   \u2022 typescript  (.ts)        \u2014 apenas .ts puro (sem JSX)
   \u2022 javascript  (.js, .jsx, .mjs, .cjs)
-  \u2022 tsx         (.tsx)       \u2014 .tsx COM JSX/React (requer lang: 'tsx')
+  \u2022 tsx         (.tsx)       \u2014 .tsx COM JSX/React
   \u2022 css         (.css, .scss, .less)
   \u2022 html        (.html, .htm)
 
+\u{1F916} AUTODETECCAO: Se o parametro 'lang' NAO for especificado, o motor
+detecta a linguagem automaticamente pela extensao de cada arquivo.
+Voce pode buscar em um diretorio com .ts e .tsx misturados \u2014 o motor
+usa o parser correto para cada arquivo.
+
+Use 'lang' apenas quando quiser RESTRINGIR a busca a uma linguagem
+especifica (ex: forcar TSX em todo o diretorio).
+
 \u26A0\uFE0F LIMITACAO IMPORTANTE: Apenas busca SINTAXICA. Nao resolve imports, nao
 entende tipos, nao segue referencias entre arquivos, nao faz analise de fluxo.
 Cada arquivo e analisado isoladamente. Para analise semantica, use ai-tool.
@@ -1109,7 +1081,7 @@ Workflow recomendado: supergrep_find \u2192 supergrep_tree \u2192 supergrep_repl
           "Padrao AST Grep na linguagem alvo. Ex: 'console.$METHOD($$$ARGS)', 'function $NAME($$$PARAMS) { $$$BODY }'"
         ),
         lang: z.string().optional().describe(
-          "Linguagem: 'typescript' (.ts), 'javascript' (.js), 'tsx' (.tsx), 'css' (.css), 'html' (.html). Default: typescript. Deixe vazio para autodeteccao por extensao."
+          "Linguagem: 'typescript' (.ts), 'javascript' (.js), 'tsx' (.tsx), 'css' (.css), 'html' (.html). Opcional \u2014 se nao especificado, o motor autodetecta pela extensao de cada arquivo."
         ),
         path: z.string().optional().describe(
           "Arquivo ou diretorio onde buscar. Default: diretorio atual. Ex: 'src/', 'app/page.tsx'"
@@ -1168,6 +1140,10 @@ Cada estrutura de codigo vira um kind diferente na AST.
 \u{1F4A1} Como usar os kinds: ao ver call_expression no tree, voce pode buscar
 chamadas de funcao com o pattern: $FUNC($$$ARGS)
 
+\u{1F916} AUTODETECCAO: se usar 'path', a linguagem e detectada automaticamente
+pela extensao do arquivo. O parametro 'lang' so e necessario ao usar
+'code' (snippet inline) ou para forcar uma linguagem especifica.
+
 QUANDO USAR:
   - "Quais tipos de nos existem neste arquivo TypeScript?"
   - "Como escrever um pattern para capturar certas estruturas?"
@@ -1244,6 +1220,10 @@ apos a substituicao. Util para planejar refatoracoes em larga escala.
   O supergrep faz interpolacao manual: textos dos nos sao concatenados
   com ", " e injetados no lugar do $VAR no rewrite.
 
+\u{1F916} AUTODETECCAO DE LINGUAGEM: se 'lang' nao for especificado, o motor
+detecta automaticamente pela extensao de cada arquivo. Use 'lang' apenas
+para RESTRINGIR a busca a uma linguagem especifica.
+
 QUANDO USAR:
   - "Como ficaria se eu trocasse console.log por logger.info?"
   - "Preview de substituir var por let em todo o projeto"
@@ -1264,7 +1244,7 @@ Workflow: supergrep_find \u2192 supergrep_replace (preview) \u2192 aplicar mudan
           "Texto de substituicao. Use $VAR para referenciar metavariaveis capturadas. Ex: 'logger.info($$$ARGS)'"
         ),
         lang: z.string().optional().describe(
-          "Linguagem: 'typescript', 'javascript', 'tsx', 'css', 'html'. Default: typescript."
+          "Linguagem: 'typescript', 'javascript', 'tsx', 'css', 'html'. Opcional \u2014 se nao especificado, o motor autodetecta pela extensao de cada arquivo."
         ),
         path: z.string().optional().describe(
           "Arquivo ou diretorio onde buscar. Default: diretorio atual."

package/dist/cli.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   startMcpServer
-} from "./chunk-SENMQNTX.js";
+} from "./chunk-5PJJZ4CK.js";
 
 // src/cli.ts
 startMcpServer().catch((err) => {

package/dist/index.d.ts

@@ -33,7 +33,6 @@ declare function startMcpServer(): Promise<void>;
  *   await startMcpServer();
  */
 
-/** Versao do pacote */
-declare const VERSION = "0.1.0";
+declare const VERSION: string;
 
 export { VERSION, startMcpServer };

package/dist/index.js

@@ -1,9 +1,12 @@
 import {
   startMcpServer
-} from "./chunk-SENMQNTX.js";
+} from "./chunk-5PJJZ4CK.js";
 
 // src/index.ts
-var VERSION = "0.1.0";
+import { createRequire } from "module";
+var require2 = createRequire(import.meta.url);
+var pkg = require2("../package.json");
+var VERSION = pkg.version;
 export {
   VERSION,
   startMcpServer

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@justmpm/supergrep",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "MCP server para busca estrutural de código com AST Grep. Encontra padrões de código com precisão sintática, ignorando formatação e comentários. Suporta 20+ linguagens via Tree-sitter.",
   "keywords": [
     "ast-grep",