@semacode/cli 1.2.17 → 1.3.1

package/README.md

@@ -36,7 +36,7 @@ sema --help
 ## Instalacao via tarball da release
 
 ```bash
-npm install -g ./sema-cli-1.2.17.tgz
+npm install -g ./{{TGZ_ARQUIVO}}
 ```
 
 Ou direto da GitHub Release:
@@ -55,7 +55,7 @@ npx sema --help
 Ou, se voce estiver testando um tarball local:
 
 ```bash
-npm install ./sema-cli-1.2.17.tgz
+npm install ./{{TGZ_ARQUIVO}}
 npx sema --help
 ```
 

package/dist/index.js

@@ -10,6 +10,9 @@ import { gerarDart } from "@sema/gerador-dart";
 import { gerarLua } from "@sema/gerador-lua";
 import { gerarPython } from "@sema/gerador-python";
 import { gerarTypeScript } from "@sema/gerador-typescript";
+import { gerarJavaScript } from "@sema/gerador-javascript";
+import { gerarHtml } from "@sema/gerador-html";
+import { gerarCss } from "@sema/gerador-css";
 import { carregarConfiguracaoProjeto, carregarProjeto, resolverAlvoPadrao, resolverAlvosVerificacao, resolverEstruturaSaidaPadrao, resolverFrameworkPadrao, resolverSaidaPadrao, } from "./projeto.js";
 import { importarProjetoLegado, resumoImportacao } from "./importador.js";
 import { analisarDriftLegado } from "./drift.js";
@@ -518,7 +521,7 @@ function validarCompatibilidadeFramework(alvo, framework) {
     if (framework === "fastapi" && alvo !== "python") {
         return `Framework "${framework}" so pode ser usado com o alvo python.`;
     }
-    if (alvo === "dart" || alvo === "lua") {
+    if (alvo === "dart" || alvo === "lua" || alvo === "javascript" || alvo === "html" || alvo === "css") {
         return `Framework "${framework}" nao e suportado para o alvo ${alvo}.`;
     }
     return undefined;
@@ -627,6 +630,15 @@ function gerarArquivosPorAlvo(ir, alvo, framework) {
     if (alvo === "lua") {
         return gerarLua(ir);
     }
+    if (alvo === "javascript") {
+        return gerarJavaScript(ir);
+    }
+    if (alvo === "html") {
+        return gerarHtml(ir);
+    }
+    if (alvo === "css") {
+        return gerarCss(ir);
+    }
     return gerarTypeScript(ir, { framework });
 }
 function aplicarEstruturaSaida(arquivos, ir, estrutura) {
@@ -665,6 +677,19 @@ function aplicarEstruturaSaida(arquivos, ir, estrutura) {
             novoBasename = `test_${nomeArquivo}.lua`;
             conteudo = conteudo.replace(`${nomeBaseAntigo}.lua`, `${nomeArquivo}.lua`);
         }
+        else if (basename === `${nomeBaseAntigo}.js`) {
+            novoBasename = `${nomeArquivo}.js`;
+        }
+        else if (basename === `${nomeBaseAntigo}.test.js`) {
+            novoBasename = `${nomeArquivo}.test.js`;
+            conteudo = conteudo.replace(`./${nomeBaseAntigo}.js`, `./${nomeArquivo}.js`);
+        }
+        else if (basename === `${nomeBaseAntigo}.html`) {
+            novoBasename = `${nomeArquivo}.html`;
+        }
+        else if (basename === `${nomeBaseAntigo}.css`) {
+            novoBasename = `${nomeArquivo}.css`;
+        }
         return {
             caminhoRelativo: pastaModulo ? path.join(pastaModulo, novoBasename) : novoBasename,
             conteudo,
@@ -672,7 +697,7 @@ function aplicarEstruturaSaida(arquivos, ir, estrutura) {
     });
 }
 function contarCasosDeTesteGerados(alvo, arquivos) {
-    if (alvo === "dart") {
+    if (alvo === "dart" || alvo === "html" || alvo === "css") {
         return 0;
     }
     if (alvo === "lua") {
@@ -689,6 +714,13 @@ function contarCasosDeTesteGerados(alvo, arquivos) {
         }
         return (arquivoTeste.conteudo.match(/\btest\(/g) ?? []).length;
     }
+    if (alvo === "javascript") {
+        const arquivoTeste = arquivos.find((item) => item.caminhoRelativo.endsWith(".test.js"));
+        if (!arquivoTeste) {
+            return 0;
+        }
+        return (arquivoTeste.conteudo.match(/\btest\(/g) ?? []).length;
+    }
     const arquivoTeste = arquivos.find((item) => path.basename(item.caminhoRelativo).startsWith("test_"));
     if (!arquivoTeste) {
         return 0;
@@ -699,17 +731,14 @@ function executarTestesGerados(alvo, baseSaida, arquivos, silencioso = false) {
     const quantidadeTestes = contarCasosDeTesteGerados(alvo, arquivos);
     if (quantidadeTestes === 0) {
         if (!silencioso) {
-            const nomeAlvo = alvo === "typescript"
-                ? "TypeScript"
-                : alvo === "python"
-                    ? "Python"
-                    : alvo === "lua"
-                        ? "Lua"
-                        : "Dart";
-            console.log(`Nenhum teste ${nomeAlvo} foi gerado.`);
+            const nomesAlvo = { typescript: "TypeScript", python: "Python", lua: "Lua", dart: "Dart", javascript: "JavaScript", html: "HTML", css: "CSS" };
+            console.log(`Nenhum teste ${nomesAlvo[alvo] ?? alvo} foi gerado.`);
         }
         return { codigoSaida: 0, quantidadeTestes, saidaPadrao: "", saidaErro: "" };
     }
+    if (alvo === "html" || alvo === "css") {
+        return { codigoSaida: 0, quantidadeTestes: 0, saidaPadrao: "", saidaErro: "" };
+    }
     if (alvo === "typescript") {
         const arquivoTeste = arquivos.find((item) => item.caminhoRelativo.endsWith(".test.ts"))?.caminhoRelativo;
         if (!arquivoTeste) {
@@ -729,6 +758,25 @@ function executarTestesGerados(alvo, baseSaida, arquivos, silencioso = false) {
             saidaErro: typeof execucao.stderr === "string" ? execucao.stderr : "",
         };
     }
+    if (alvo === "javascript") {
+        const arquivoTeste = arquivos.find((item) => item.caminhoRelativo.endsWith(".test.js"))?.caminhoRelativo;
+        if (!arquivoTeste) {
+            if (!silencioso) {
+                console.log("Nenhum teste JavaScript foi gerado.");
+            }
+            return { codigoSaida: 0, quantidadeTestes, saidaPadrao: "", saidaErro: "" };
+        }
+        const execucao = spawnSync("node", ["--test", path.join(baseSaida, arquivoTeste)], {
+            stdio: silencioso ? "pipe" : "inherit",
+            encoding: silencioso ? "utf8" : undefined,
+        });
+        return {
+            codigoSaida: execucao.status ?? 1,
+            quantidadeTestes,
+            saidaPadrao: typeof execucao.stdout === "string" ? execucao.stdout : "",
+            saidaErro: typeof execucao.stderr === "string" ? execucao.stderr : "",
+        };
+    }
     if (alvo === "lua") {
         const arquivoTeste = arquivos.find((item) => path.basename(item.caminhoRelativo).startsWith("test_") && item.caminhoRelativo.endsWith(".lua"))?.caminhoRelativo;
         if (!arquivoTeste) {

package/dist/projeto.js

@@ -59,9 +59,12 @@ export function normalizarFrameworkGeracao(valor) {
     return "base";
 }
 function normalizarAlvo(valor) {
-    if (valor === "typescript" || valor === "python" || valor === "dart" || valor === "lua") {
+    if (valor === "typescript" || valor === "python" || valor === "dart" || valor === "lua" || valor === "javascript" || valor === "html" || valor === "css") {
         return valor;
     }
+    if (valor === "js") {
+        return "javascript";
+    }
     return undefined;
 }
 function resolverEntradaPadrao(cwd, configCarregada) {

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@semacode/cli",
-  "version": "1.2.17",
-  "description": "CLI da Sema para validar contratos, medir drift e governar a navegacao operacional de agentes sobre software vivo em backend e front consumer.",
+  "version": "1.3.1",
   "type": "module",
-  "icon": "logo.png",
+  "description": "CLI da Sema para validar contratos, medir drift e governar a navegacao operacional de agentes sobre software vivo em backend e front consumer.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -28,41 +27,36 @@
   "publishConfig": {
     "access": "public"
   },
+  "icon": "logo.png",
   "bin": {
     "sema": "dist/index.js"
   },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "files": [
-    "dist",
-    "docs",
-    "exemplos",
-    "AGENTS.md",
-    "llms.txt",
-    "llms-full.txt",
-    "SEMA_BRIEF.md",
-    "SEMA_BRIEF.micro.txt",
-    "SEMA_BRIEF.curto.txt",
-    "SEMA_INDEX.json",
-    "logo.png",
-    "README.md",
-    "LICENSE"
-  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  },
   "dependencies": {
-    "@sema/nucleo": "1.2.17",
-    "@sema/gerador-dart": "1.2.17",
-    "@sema/gerador-lua": "1.2.17",
-    "@sema/gerador-python": "1.2.17",
-    "@sema/gerador-typescript": "1.2.17",
-    "@sema/padroes": "1.2.17",
+    "@sema/nucleo": "1.3.1",
+    "@sema/gerador-dart": "1.3.1",
+    "@sema/gerador-lua": "1.3.1",
+    "@sema/gerador-python": "1.3.1",
+    "@sema/gerador-typescript": "1.3.1",
+    "@sema/gerador-javascript": "1.3.1",
+    "@sema/gerador-html": "1.3.1",
+    "@sema/gerador-css": "1.3.1",
+    "@sema/padroes": "1.3.1",
     "typescript": "^5.8.3"
   },
-  "bundledDependencies": [
+  "bundleDependencies": [
     "@sema/nucleo",
+    "@sema/padroes",
+    "@sema/gerador-typescript",
+    "@sema/gerador-python",
     "@sema/gerador-dart",
     "@sema/gerador-lua",
-    "@sema/gerador-python",
-    "@sema/gerador-typescript",
-    "@sema/padroes"
+    "@sema/gerador-javascript",
+    "@sema/gerador-html",
+    "@sema/gerador-css"
   ]
-}
+}

package/src/cpp-symbols.ts

@@ -0,0 +1,82 @@
+export interface SimboloCppExtraido {
+  simbolo: string;
+  retorno?: string;
+  parametros: Array<{ nome: string; tipoTexto?: string; obrigatorio: boolean }>;
+}
+
+function extrairParametrosCpp(assinatura: string): Array<{ nome: string; tipoTexto?: string; obrigatorio: boolean }> {
+  return assinatura.split(",").map((parametroBruto) => {
+    const parametro = parametroBruto.trim();
+    if (!parametro || parametro === "void") {
+      return undefined;
+    }
+    const semPadrao = parametro.split("=")[0]?.trim() ?? parametro;
+    const partes = semPadrao.split(/\s+/).filter(Boolean);
+    if (partes.length < 2) {
+      return undefined;
+    }
+    const nome = partes.at(-1)!.replace(/[&*]+$/, "");
+    const tipoTexto = partes.slice(0, -1).join(" ");
+    return {
+      nome,
+      tipoTexto,
+      obrigatorio: !parametro.includes("="),
+    };
+  }).filter((item): item is NonNullable<typeof item> => Boolean(item));
+}
+
+export function extrairSimbolosCpp(codigo: string): SimboloCppExtraido[] {
+  const simbolos = new Map<string, SimboloCppExtraido>();
+
+  for (const match of codigo.matchAll(/(?:^|\n)\s*(?:inline\s+|static\s+|virtual\s+|constexpr\s+|friend\s+|extern\s+|template\s*<[^>]+>\s*)*(?:[\w:<>~*&]+\s+)+([A-Za-z_]\w*)::([A-Za-z_]\w*)\s*\(([^)]*)\)\s*(?:const)?\s*(?:\{|;)/g)) {
+    const simbolo = `${match[1]!}.${match[2]!}`;
+    simbolos.set(simbolo, {
+      simbolo,
+      parametros: extrairParametrosCpp(match[3] ?? ""),
+    });
+  }
+
+  for (const match of codigo.matchAll(/(?:^|\n)\s*(?:inline\s+|static\s+|virtual\s+|constexpr\s+|friend\s+|extern\s+)*(?:[\w:<>~*&]+\s+)+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*(?:const)?\s*(?:\{|;)/g)) {
+    const nome = match[1]!;
+    if (["if", "for", "while", "switch", "return"].includes(nome)) {
+      continue;
+    }
+    if (!simbolos.has(nome)) {
+      simbolos.set(nome, {
+        simbolo: nome,
+        parametros: extrairParametrosCpp(match[2] ?? ""),
+      });
+    }
+  }
+
+  const pilhaClasses: string[] = [];
+  for (const linha of codigo.split(/\r?\n/)) {
+    const trim = linha.trim();
+    const classe = trim.match(/^(?:class|struct)\s+([A-Za-z_]\w*)/);
+    if (classe) {
+      pilhaClasses.push(classe[1]!);
+      continue;
+    }
+    if (trim.startsWith("};") || trim === "}" || trim === "};") {
+      pilhaClasses.pop();
+      continue;
+    }
+
+    const metodoClasse = trim.match(/^(?:inline\s+|static\s+|virtual\s+|constexpr\s+)*(?:[\w:<>~*&]+\s+)+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*(?:const)?\s*\{/);
+    if (metodoClasse && pilhaClasses.length > 0) {
+      const nomeClasse = pilhaClasses[pilhaClasses.length - 1]!;
+      const nomeMetodo = metodoClasse[1]!;
+      if (!["if", "for", "while", "switch"].includes(nomeMetodo)) {
+        const simbolo = `${nomeClasse}.${nomeMetodo}`;
+        if (!simbolos.has(simbolo)) {
+          simbolos.set(simbolo, {
+            simbolo,
+            parametros: extrairParametrosCpp(metodoClasse[2] ?? ""),
+          });
+        }
+      }
+    }
+  }
+
+  return [...simbolos.values()];
+}

package/src/dotnet-http.ts

@@ -0,0 +1,355 @@
+export interface ParametroRotaBackend {
+  nome: string;
+  tipoSema: "Texto" | "Inteiro" | "Decimal" | "Id";
+}
+
+export interface SimboloDotnetExtraido {
+  simbolo: string;
+  retorno?: string;
+  parametros: Array<{ nome: string; tipoTexto?: string; obrigatorio: boolean }>;
+}
+
+export interface RotaDotnetExtraida {
+  origem: "dotnet";
+  metodo: string;
+  caminho: string;
+  simbolo: string;
+  parametros: ParametroRotaBackend[];
+  retorno?: string;
+}
+
+const METODOS_HTTP = new Set(["GET", "POST", "PUT", "PATCH", "DELETE"]);
+
+function normalizarCaminhoBase(caminho?: string): string | undefined {
+  if (!caminho) {
+    return undefined;
+  }
+  return caminho.replace(/^\/+|\/+$/g, "");
+}
+
+function juntarCaminho(base: string | undefined, sufixo: string | undefined): string {
+  const partes = [base, sufixo]
+    .map((parte) => normalizarCaminhoBase(parte))
+    .filter((parte): parte is string => Boolean(parte));
+  return `/${partes.join("/")}`.replace(/\/+/g, "/");
+}
+
+function normalizarCaminhoAspNet(caminho: string, classe?: string, metodo?: string): string {
+  const controller = (classe ?? "").replace(/Controller$/i, "");
+  const action = metodo ?? "";
+  return caminho
+    .replace(/\[controller\]/gi, controller ? controller.toLowerCase() : "controller")
+    .replace(/\[action\]/gi, action ? action.toLowerCase() : "action")
+    .replace(/\{([^}:]+):[^}]+\}/g, "{$1}")
+    .replace(/\/+/g, "/");
+}
+
+function mapearTipoRotaDotnet(tipo?: string): ParametroRotaBackend["tipoSema"] {
+  const normalizado = (tipo ?? "").toLowerCase();
+  if (/(^|\.)(int|int32|int64|long|short)$/.test(normalizado)) {
+    return "Inteiro";
+  }
+  if (/(^|\.)(float|double|decimal)$/.test(normalizado)) {
+    return "Decimal";
+  }
+  if (/guid|uuid|id$/i.test(normalizado)) {
+    return "Id";
+  }
+  return "Texto";
+}
+
+function extrairParametrosRota(caminho: string, assinatura: string): ParametroRotaBackend[] {
+  const tiposAssinatura = new Map<string, string>();
+  for (const parametroBruto of assinatura.split(",")) {
+    const parametro = parametroBruto.trim();
+    if (!parametro) {
+      continue;
+    }
+    const semPadrao = parametro.split("=")[0]?.trim() ?? parametro;
+    const partes = semPadrao.split(/\s+/).filter(Boolean);
+    if (partes.length < 2) {
+      continue;
+    }
+    const nome = partes.at(-1)!;
+    const tipo = partes.slice(0, -1).join(" ");
+    tiposAssinatura.set(nome, tipo);
+  }
+
+  return [...caminho.matchAll(/\{([^}:]+)(?::[^}]+)?\}/g)].map((match) => {
+    const nome = match[1]!;
+    return {
+      nome,
+      tipoSema: mapearTipoRotaDotnet(tiposAssinatura.get(nome)),
+    };
+  });
+}
+
+function extrairTextoAtributo(atributo: string): string | undefined {
+  return atributo.match(/"([^"]+)"/)?.[1];
+}
+
+function extrairMetodosAtributo(atributo: string): string[] {
+  const direto = atributo.match(/\[\s*Http(Get|Post|Put|Patch|Delete)\b/i)?.[1]?.toUpperCase();
+  if (direto && METODOS_HTTP.has(direto)) {
+    return [direto];
+  }
+
+  const bloco = atributo.match(/\bHttpMethods\.(Get|Post|Put|Patch|Delete)\b/gi)
+    ?.map((item) => item.split(".").pop()?.toUpperCase() ?? "")
+    .filter((item) => METODOS_HTTP.has(item));
+  if (bloco && bloco.length > 0) {
+    return [...new Set(bloco)];
+  }
+
+  const requestMapping = atributo.match(/\[\s*AcceptVerbs\(([^)]*)\)\s*\]/i)?.[1];
+  if (requestMapping) {
+    const encontrados = [...requestMapping.matchAll(/"([A-Za-z]+)"/g)]
+      .map((match) => match[1]!.toUpperCase())
+      .filter((item) => METODOS_HTTP.has(item));
+    if (encontrados.length > 0) {
+      return [...new Set(encontrados)];
+    }
+  }
+
+  return [];
+}
+
+function contarChar(texto: string, alvo: string): number {
+  return [...texto].filter((char) => char === alvo).length;
+}
+
+function atualizarPilhaClasses<T extends { profundidade: number }>(pilha: T[], profundidade: number): void {
+  while (pilha.length > 0 && profundidade < pilha[pilha.length - 1]!.profundidade) {
+    pilha.pop();
+  }
+}
+
+function extrairAtributos(linhas: string[], inicio: number): { atributos: string[]; proximoIndice: number } {
+  const atributos: string[] = [];
+  let indice = inicio;
+
+  while (indice < linhas.length) {
+    const linha = linhas[indice]!.trim();
+    if (!linha.startsWith("[")) {
+      break;
+    }
+    let atual = linha;
+    let saldo = contarChar(linha, "[") - contarChar(linha, "]");
+    while (saldo > 0 && indice + 1 < linhas.length) {
+      indice += 1;
+      const complemento = linhas[indice]!.trim();
+      atual += ` ${complemento}`;
+      saldo += contarChar(complemento, "[") - contarChar(complemento, "]");
+    }
+    atributos.push(atual);
+    indice += 1;
+  }
+
+  return { atributos, proximoIndice: indice };
+}
+
+export function extrairSimbolosDotnet(codigo: string): SimboloDotnetExtraido[] {
+  const simbolos = new Map<string, SimboloDotnetExtraido>();
+  const linhas = codigo.split(/\r?\n/);
+  const pilhaClasses: Array<{ nome: string; profundidade: number }> = [];
+  let classePendente: { nome: string; profundidade: number } | undefined;
+  let profundidade = 0;
+
+  for (let indice = 0; indice < linhas.length; indice += 1) {
+    const linhaOriginal = linhas[indice]!;
+    const linha = linhaOriginal.trim();
+    if (classePendente && linha.startsWith("{")) {
+      pilhaClasses.push(classePendente);
+      classePendente = undefined;
+    }
+    if (!linha || linha.startsWith("//")) {
+      profundidade += contarChar(linhaOriginal, "{") - contarChar(linhaOriginal, "}");
+      atualizarPilhaClasses(pilhaClasses, profundidade);
+      continue;
+    }
+
+    const { atributos, proximoIndice } = extrairAtributos(linhas, indice);
+    if (atributos.length > 0) {
+      indice = proximoIndice;
+    }
+
+    const linhaEfetiva = (linhas[indice] ?? "").trim();
+    const classe = linhaEfetiva.match(/\bclass\s+([A-Za-z_]\w*)/);
+    if (classe) {
+      const entrada = { nome: classe[1]!, profundidade: profundidade + 1 };
+      if (linhaEfetiva.includes("{")) {
+        pilhaClasses.push(entrada);
+      } else {
+        classePendente = entrada;
+      }
+      profundidade += contarChar(linhaEfetiva, "{") - contarChar(linhaEfetiva, "}");
+      atualizarPilhaClasses(pilhaClasses, profundidade);
+      continue;
+    }
+
+    const metodo = linhaEfetiva.match(/\b(?:public|internal|protected|private)\s+(?:static\s+|async\s+|virtual\s+|override\s+|sealed\s+|partial\s+)*([A-Za-z0-9_<>,.?[\]\s]+)\s+([A-Za-z_]\w*)\s*\(([^)]*)\)/);
+    if (metodo) {
+      const classeAtual = pilhaClasses[pilhaClasses.length - 1];
+      const simbolo = classeAtual ? `${classeAtual.nome}.${metodo[2]!}` : metodo[2]!;
+      simbolos.set(simbolo, {
+        simbolo,
+        retorno: metodo[1]!.trim(),
+        parametros: metodo[3]!.split(",").flatMap((parametroBruto) => {
+          const parametro = parametroBruto.trim();
+          if (!parametro) {
+            return [];
+          }
+          const semPadrao = parametro.split("=")[0]?.trim() ?? parametro;
+          const partes = semPadrao.split(/\s+/).filter(Boolean);
+          if (partes.length < 2) {
+            return [];
+          }
+          return [{
+            nome: partes.at(-1)!,
+            tipoTexto: partes.slice(0, -1).join(" "),
+            obrigatorio: !parametro.includes("="),
+          }];
+        }),
+      });
+      profundidade += contarChar(linhaEfetiva, "{") - contarChar(linhaEfetiva, "}");
+      atualizarPilhaClasses(pilhaClasses, profundidade);
+      continue;
+    }
+
+    const funcaoLocal = linhaEfetiva.match(/\b([A-Za-z0-9_<>,.?[\]\s]+)\s+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*=>/);
+    if (funcaoLocal && atributos.length === 0 && pilhaClasses.length === 0) {
+      const simbolo = funcaoLocal[2]!;
+      simbolos.set(simbolo, {
+        simbolo,
+        retorno: funcaoLocal[1]!.trim(),
+        parametros: [],
+      });
+    }
+
+    const funcaoTopo = linhaEfetiva.match(/\b(?:static\s+)?([A-Za-z0-9_<>,.?[\]\s]+)\s+([A-Za-z_]\w*)\s*\(([^)]*)\)\s*(?:\{|$)/);
+    if (funcaoTopo && atributos.length === 0 && pilhaClasses.length === 0 && !["if", "for", "while", "switch"].includes(funcaoTopo[2]!)) {
+      const simbolo = funcaoTopo[2]!;
+      if (!simbolos.has(simbolo)) {
+        simbolos.set(simbolo, {
+          simbolo,
+          retorno: funcaoTopo[1]!.trim(),
+          parametros: funcaoTopo[3]!.split(",").flatMap((parametroBruto) => {
+            const parametro = parametroBruto.trim();
+            if (!parametro) {
+              return [];
+            }
+            const semPadrao = parametro.split("=")[0]?.trim() ?? parametro;
+            const partes = semPadrao.split(/\s+/).filter(Boolean);
+            if (partes.length < 2) {
+              return [];
+            }
+            return [{
+              nome: partes.at(-1)!,
+              tipoTexto: partes.slice(0, -1).join(" "),
+              obrigatorio: !parametro.includes("="),
+            }];
+          }),
+        });
+      }
+    }
+
+    profundidade += contarChar(linhaEfetiva, "{") - contarChar(linhaEfetiva, "}");
+    atualizarPilhaClasses(pilhaClasses, profundidade);
+  }
+
+  return [...simbolos.values()];
+}
+
+export function extrairRotasDotnet(codigo: string): RotaDotnetExtraida[] {
+  const rotas = new Map<string, RotaDotnetExtraida>();
+  const linhas = codigo.split(/\r?\n/);
+  const pilhaClasses: Array<{ nome: string; profundidade: number; rotaBase?: string; apiController: boolean }> = [];
+  let classePendente: { nome: string; profundidade: number; rotaBase?: string; apiController: boolean } | undefined;
+  let profundidade = 0;
+
+  for (let indice = 0; indice < linhas.length; indice += 1) {
+    const linhaOriginal = linhas[indice]!;
+    const linha = linhaOriginal.trim();
+    if (classePendente && linha.startsWith("{")) {
+      pilhaClasses.push(classePendente);
+      classePendente = undefined;
+    }
+    if (!linha || linha.startsWith("//")) {
+      profundidade += contarChar(linhaOriginal, "{") - contarChar(linhaOriginal, "}");
+      atualizarPilhaClasses(pilhaClasses, profundidade);
+      continue;
+    }
+
+    const { atributos, proximoIndice } = extrairAtributos(linhas, indice);
+    if (atributos.length > 0) {
+      indice = proximoIndice;
+    }
+
+    const linhaEfetiva = (linhas[indice] ?? "").trim();
+    const classe = linhaEfetiva.match(/\bclass\s+([A-Za-z_]\w*)/);
+    if (classe) {
+      const rotaBase = atributos
+        .map((atributo) => extrairTextoAtributo(atributo))
+        .find(Boolean);
+      const entrada = {
+        nome: classe[1]!,
+        profundidade: profundidade + 1,
+        rotaBase,
+        apiController: atributos.some((atributo) => /\[\s*ApiController\s*\]/i.test(atributo)),
+      };
+      if (linhaEfetiva.includes("{")) {
+        pilhaClasses.push(entrada);
+      } else {
+        classePendente = entrada;
+      }
+      profundidade += contarChar(linhaEfetiva, "{") - contarChar(linhaEfetiva, "}");
+      atualizarPilhaClasses(pilhaClasses, profundidade);
+      continue;
+    }
+
+    const classeAtual = pilhaClasses[pilhaClasses.length - 1];
+    const metodo = linhaEfetiva.match(/\b(?:public|internal|protected)\s+(?:async\s+|virtual\s+|override\s+|static\s+)*([A-Za-z0-9_<>,.?[\]\s]+)\s+([A-Za-z_]\w*)\s*\(([^)]*)\)/);
+    if (metodo && classeAtual) {
+      const atributosMetodo = atributos.filter((atributo) => /\[\s*(?:Http|AcceptVerbs)/i.test(atributo));
+      for (const atributo of atributosMetodo) {
+        const metodos = extrairMetodosAtributo(atributo);
+        const rotaMetodo = extrairTextoAtributo(atributo);
+        for (const httpMetodo of metodos) {
+          const caminho = normalizarCaminhoAspNet(
+            juntarCaminho(classeAtual.rotaBase, rotaMetodo),
+            classeAtual.nome,
+            metodo[2]!,
+          );
+          const registro: RotaDotnetExtraida = {
+            origem: "dotnet",
+            metodo: httpMetodo,
+            caminho,
+            simbolo: `${classeAtual.nome}.${metodo[2]!}`,
+            parametros: extrairParametrosRota(caminho, metodo[3] ?? ""),
+            retorno: metodo[1]!.trim(),
+          };
+          rotas.set(`${registro.metodo}:${registro.caminho}:${registro.simbolo}`, registro);
+        }
+      }
+    }
+
+    for (const match of linhaEfetiva.matchAll(/\b\w+\.Map(Get|Post|Put|Patch|Delete)\(\s*"([^"]+)"\s*,\s*([A-Za-z_][\w.]*)/g)) {
+      const httpMetodo = match[1]!.toUpperCase();
+      const caminho = normalizarCaminhoAspNet(match[2]!);
+      const simbolo = match[3]!;
+      const registro: RotaDotnetExtraida = {
+        origem: "dotnet",
+        metodo: httpMetodo,
+        caminho,
+        simbolo,
+        parametros: extrairParametrosRota(caminho, ""),
+      };
+      rotas.set(`${registro.metodo}:${registro.caminho}:${registro.simbolo}`, registro);
+    }
+
+    profundidade += contarChar(linhaEfetiva, "{") - contarChar(linhaEfetiva, "}");
+    atualizarPilhaClasses(pilhaClasses, profundidade);
+  }
+
+  return [...rotas.values()];
+}