@justmpm/supergrep 0.1.1 → 0.2.1

package/dist/{chunk-SENMQNTX.js → chunk-LUKDYG3I.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 as resolve2 } from "path";
+import { stat } from "fs/promises";
 
 // src/utils/lang.ts
 import { Lang } from "@ast-grep/napi";
@@ -65,10 +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",
@@ -84,51 +80,148 @@ function shouldIgnoreFile(filePath) {
   }
   return false;
 }
-var IGNORED_DIRS = [
+
+// src/utils/find-fallback.ts
+import { parse } from "@ast-grep/napi";
+import { readdir, readFile, stat as fsStat } from "fs/promises";
+import { join, extname, resolve } from "path";
+var LANG_EXTENSIONS = {
+  Html: [".html", ".htm"],
+  Css: [".css", ".scss", ".less"]
+};
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
   "node_modules",
+  ".git",
   "dist",
   "build",
-  ".git",
   ".next",
   ".turbo",
   "coverage",
   "out"
-];
+]);
+async function findInFilesFallback(lang, config) {
+  const langStr = String(lang);
+  const extensions = LANG_EXTENSIONS[langStr];
+  if (!extensions) {
+    return [];
+  }
+  const results = [];
+  for (const searchPath of config.paths) {
+    const absPath = resolve(searchPath);
+    try {
+      const pathStat = await fsStat(absPath);
+      if (pathStat.isFile()) {
+        const ext = extname(absPath).toLowerCase();
+        if (extensions.some((e) => ext === e)) {
+          await processFile(absPath, lang, config.matcher, results);
+        }
+      } else if (pathStat.isDirectory()) {
+        await walkDir(absPath, lang, extensions, config.matcher, results);
+      }
+    } catch {
+      continue;
+    }
+  }
+  return results;
+}
+async function processFile(filePath, lang, matcher, results) {
+  if (shouldIgnoreFile(filePath)) return;
+  let source;
+  try {
+    source = await readFile(filePath, "utf-8");
+  } catch {
+    return;
+  }
+  let ast;
+  try {
+    ast = parse(lang, source);
+  } catch {
+    return;
+  }
+  try {
+    const nodes = [...ast.root().findAll(matcher)];
+    if (nodes.length > 0) {
+      results.push({ file: filePath, nodes });
+    }
+  } catch {
+    return;
+  }
+}
+async function walkDir(dirPath, lang, extensions, matcher, results) {
+  let entries;
+  try {
+    entries = await readdir(dirPath, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    const fullPath = join(dirPath, entry.name);
+    if (entry.isDirectory()) {
+      if (IGNORED_DIRS.has(entry.name)) continue;
+      if (entry.name.startsWith(".")) continue;
+      await walkDir(fullPath, lang, extensions, matcher, results);
+    } else if (entry.isFile()) {
+      const ext = extname(entry.name).toLowerCase();
+      if (extensions.includes(ext)) {
+        await processFile(fullPath, lang, matcher, results);
+      }
+    }
+  }
+}
 
 // src/tools/find.ts
+function isHtmlCssLang(lang) {
+  const langStr = String(lang);
+  return langStr === "Html" || langStr === "Css";
+}
 var MULTI_META_RE = /\$\$\$([A-Z_][A-Z0-9_]*)/g;
 var SINGLE_META_RE = /(?<!\$)\$(?:\$\$)?([A-Z_][A-Z0-9_]*)/g;
 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 = resolve2(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) {
+  const useFallback = lang !== void 0 && isHtmlCssLang(lang);
+  try {
+    const fileResults = useFallback ? await findInFilesFallback(lang, { paths: [searchPath], matcher: napiConfig }) : 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 +238,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 +282,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;
@@ -293,8 +354,8 @@ 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 { readFile as readFile2, stat as stat2 } from "fs/promises";
+import { resolve as resolve3, relative as relative2, extname as extname2 } from "path";
 async function exploreTree(options) {
   const warnings = [];
   const cwd = options.cwd ?? process.cwd();
@@ -313,9 +374,9 @@ async function exploreTree(options) {
       detectedLang = resolveLang("typescript");
     }
   } else if (options.path) {
-    filePath = resolve2(cwd, options.path);
+    filePath = resolve3(cwd, options.path);
     try {
-      await stat(filePath);
+      await stat2(filePath);
     } catch {
       throw new FileNotFoundError(filePath);
     }
@@ -393,9 +454,13 @@ 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 resolve4, relative as relative3 } from "path";
+import { stat as stat3 } from "fs/promises";
+function isHtmlCssLang2(lang) {
+  const langStr = String(lang);
+  return langStr === "Html" || langStr === "Css";
+}
 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 +483,29 @@ 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 = resolve4(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) {
+  const useFallback = isHtmlCssLang2(lang);
+  try {
+    const fileResults = useFallback ? await findInFilesFallback(lang, { paths: [searchPath], matcher: napiConfig }) : 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) {
@@ -447,22 +523,22 @@ async function replacePreview(options) {
         let interpolated = options.rewrite;
         for (const [name, value] of Object.entries(metaVarValues)) {
           interpolated = interpolated.replaceAll(
-            new RegExp(`\\$${name}\\b`, "g"),
+            new RegExp(`\\$+${name}\\b`, "g"),
             value
           );
         }
         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 +547,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 +575,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,9 +1129,17 @@ 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 css         (.css, .scss, .less)
-  \u2022 html        (.html, .htm)
+  \u2022 tsx         (.tsx)       \u2014 .tsx COM JSX/React
+  \u2022 css         (.css, .scss, .less)  \u26A0\uFE0F Motor usa fallback manual (findInFiles napi nao suporta nativamente)
+  \u2022 html        (.html, .htm)        \u26A0\uFE0F Motor usa fallback manual (findInFiles napi nao suporta nativamente)
+
+\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.
@@ -1085,12 +1170,30 @@ Cada arquivo e analisado isoladamente. Para analise semantica, use ai-tool.
 \u{1F4DD} EXEMPLOS DE PATTERNS:
   \u2022 console.$METHOD($MSG)              \u2192 captura metodo e 1 argumento
   \u2022 console.$METHOD($$$ARGS)           \u2192 captura metodo e todos os argumentos
-  \u2022 function $NAME($$$PARAMS) { $$$BODY }  \u2192 captura funcoes completas
+  \u2022 $FUNC($$$ARGS)                     \u2192 captura qualquer chamada de funcao (use para call_expression)
   \u2022 import { $$$ITEMS } from '$MODULE'     \u2192 captura imports
-  \u2022 const $VAR = $VALUE                \u2192 captura declaracoes
+  \u2022 const $VAR = $VALUE                \u2192 captura declaracoes simples
+  \u2022 const $VAR: $TYPE = $VALUE         \u2192 captura declaracoes com tipo (sempre inclua o =)
   \u2022 try { $$$ } catch ($ERR) { $$$ }   \u2192 captura try-catch
   \u2022 await $FUNC($$$ARGS)               \u2192 captura chamadas assincronas
 
+\u26A0\uFE0F PATTERNS PARA FUNCOES TYPESCRIPT (IMPORTANTE):
+  Funcoes TS frequentemente tem tipo de retorno (: Type) como no nomeado extra.
+  Se o pattern nao incluir o tipo de retorno, o match FALHA. Use:
+  \u2705 function $NAME($$$PARAMS): $_RET { $$$BODY }
+  \u2705 function $NAME($$$PARAMS): $_RET_TYPE { $$$BODY }
+  \u2705 const $NAME = ($PARAM: $TYPE): $_RET => { $$$BODY }
+  \u274C function $NAME($$$PARAMS) { $$$BODY }  \u2014 falha se houver tipo de retorno
+  O $_RET (com underscore) age como "coringa nao-capturador" para o tipo de retorno.
+
+\u26A0\uFE0F PATTERNS CSS PRECISAM DE CONTEXTO:
+  Padroes CSS sem contexto sao ambiguos para o parser. Use:
+  \u2705 $SELECTOR { $$$ }       \u2014 captura qualquer regra CSS completa
+  \u2705 $PROP: $VALUE           \u2014 captura propriedade (dentro de uma regra)
+  \u2705 * { $$$ }               \u2014 qualquer regra CSS
+  \u274C .className { $$$ }      \u2014 falha (ponto no inicio e ambiguo)
+  \u274C margin: 0               \u2014 sem contexto, use $PROP: $VALUE
+
 \u{1F524} METAVARIAVEIS:
   \u2022 $VAR    \u2192 captura UM no nomeado (ex: um identificador, uma string, um numero)
   \u2022 $$VAR   \u2192 captura UM no (incluindo nos nao-nomeados como operadores +, -)
@@ -1109,7 +1212,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. Para HTML/CSS, o motor usa fallback parse direto (findInFiles nao suporta nativamente)."
         ),
         path: z.string().optional().describe(
           "Arquivo ou diretorio onde buscar. Default: diretorio atual. Ex: 'src/', 'app/page.tsx'"
@@ -1168,6 +1271,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 +1351,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 +1375,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. Para HTML/CSS, o motor usa fallback parse direto (findInFiles nao suporta nativamente)."
         ),
         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-LUKDYG3I.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-LUKDYG3I.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.1",
   "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",