@semacode/cli 1.3.2 → 1.3.5

package/README.md

@@ -36,7 +36,7 @@ sema --help
 ## Instalacao via tarball da release
 
 ```bash
-npm install -g ./sema-cli-1.3.2.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.3.2.tgz
+npm install ./{{TGZ_ARQUIVO}}
 npx sema --help
 ```
 

package/dist/index.js

@@ -60,8 +60,8 @@ Comandos essenciais:
 - validacao: \`sema validar <arquivo.sema> --json\`
 - diagnosticos: \`sema diagnosticos <arquivo.sema> --json\`
 - formatacao: \`sema formatar <arquivo.sema>\`
-- importacao assistida de legado: \`sema importar <nestjs|fastapi|flask|nextjs|nextjs-consumer|react-vite-consumer|angular-consumer|flutter-consumer|firebase|dotnet|java|go|rust|cpp|typescript|python|dart> <diretorio> --saida <diretorio>\`
-- geracao de codigo: \`sema compilar <arquivo-ou-pasta> --alvo <typescript|python|dart|lua> --saida <diretorio>\`
+- importacao assistida de legado: \`sema importar <nestjs|fastapi|flask|nextjs|nextjs-consumer|react-vite-consumer|angular-consumer|flutter-consumer|firebase|dotnet|java|go|rust|cpp|typescript|python|dart> <diretorio> --saida <diretorio>\`
+- geracao de codigo: \`sema compilar <arquivo-ou-pasta> --alvo <typescript|python|dart|lua> --saida <diretorio>\`
 - verificacao final: \`sema verificar <arquivo-ou-pasta> [--json]\`
 
 Antes de editar:
@@ -100,24 +100,24 @@ Superficies que a IA deve enxergar como first-class:
 
 Nao improvise quando faltar contexto.
 `;
-const PROMPT_BASE_IA = `Voce esta trabalhando com Sema, um Protocolo de Governanca de Intencao orientado a contrato, desenhado para operacao por IA.
-
-Trate a Sema como camada semantica e linguagem de especificacao executavel feita para IA, nao para leitura humana confortavel. Nao invente sintaxe, palavras-chave ou blocos fora da gramatica e dos exemplos oficiais.
-
-Fontes de verdade, em ordem:
-1. se o projeto expuser \`SEMA_CONTEXT.md\`, comece por ele
-2. \`SEMA_BRIEF.md\`
-3. \`SEMA_INDEX.json\`
-4. README do projeto
-5. gramatica e documentacao de sintaxe da Sema
-6. especificacao semantica da linguagem
-7. exemplos oficiais, com prioridade para o vertical de pagamento
-8. \`sema resumo\` e \`briefing.min.json\` quando a IA for pequena
-9. AST, IR e diagnosticos exportados pela CLI em JSON quando a capacidade aguentar
-
-Regras de operacao:
-- preserve o significado semantico
-- use o formatador oficial da Sema como fonte unica de estilo
+const PROMPT_BASE_IA = `Voce esta trabalhando com Sema, um Protocolo de Governanca de Intencao orientado a contrato, desenhado para operacao por IA.
+
+Trate a Sema como camada semantica e linguagem de especificacao executavel feita para IA, nao para leitura humana confortavel. Nao invente sintaxe, palavras-chave ou blocos fora da gramatica e dos exemplos oficiais.
+
+Fontes de verdade, em ordem:
+1. se o projeto expuser \`SEMA_CONTEXT.md\`, comece por ele
+2. \`SEMA_BRIEF.md\`
+3. \`SEMA_INDEX.json\`
+4. README do projeto
+5. gramatica e documentacao de sintaxe da Sema
+6. especificacao semantica da linguagem
+7. exemplos oficiais, com prioridade para o vertical de pagamento
+8. \`sema resumo\` e \`briefing.min.json\` quando a IA for pequena
+9. AST, IR e diagnosticos exportados pela CLI em JSON quando a capacidade aguentar
+
+Regras de operacao:
+- preserve o significado semantico
+- use o formatador oficial da Sema como fonte unica de estilo
 - use diagnosticos estruturados como contrato de correcao
 - use a IR como fonte de verdade semantica quando houver duvida
 - nao conclua uma alteracao sem validar e verificar o modulo
@@ -432,29 +432,35 @@ async function escreverArquivos(base, arquivos) {
     }
 }
 function obterOpcao(args, nome, padrao) {
-    const indice = args.findIndex((arg) => arg === nome);
-    if (indice === -1) {
-        return padrao;
+    const nomes = [nome, ...Object.entries(ALIAS_OPCOES).filter(([, v]) => v === nome).map(([k]) => k)];
+    for (const n of nomes) {
+        const indice = args.findIndex((arg) => arg === n);
+        if (indice !== -1)
+            return args[indice + 1] ?? padrao;
     }
-    return args[indice + 1] ?? padrao;
+    return padrao;
 }
 function possuiFlag(args, nome) {
     return args.includes(nome);
 }
 const OPCOES_COM_VALOR = new Set([
     "--template",
-    "--alvo",
-    "--saida",
+    "--alvo", "-a",
+    "--saida", "-s",
     "--estrutura",
     "--framework",
     "--namespace",
     "--para",
 ]);
+const ALIAS_OPCOES = {
+    "-a": "--alvo",
+    "-s": "--saida",
+};
 function obterPosicionais(args) {
     const posicionais = [];
     for (let indice = 0; indice < args.length; indice += 1) {
         const atual = args[indice];
-        if (atual.startsWith("--")) {
+        if (atual.startsWith("-")) {
             if (OPCOES_COM_VALOR.has(atual)) {
                 indice += 1;
             }

package/package.json

@@ -1,9 +1,8 @@
 {
   "name": "@semacode/cli",
-  "version": "1.3.2",
-  "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.5",
   "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,47 +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.3.2",
-    "@sema/gerador-dart": "1.3.2",
-    "@sema/gerador-lua": "1.3.2",
-    "@sema/gerador-python": "1.3.2",
-    "@sema/gerador-typescript": "1.3.2",
-    "@sema/gerador-javascript": "1.3.2",
-    "@sema/gerador-html": "1.3.2",
-    "@sema/gerador-css": "1.3.2",
-    "@sema/padroes": "1.3.2",
+    "@sema/nucleo": "file:../nucleo",
+    "@sema/gerador-dart": "file:../gerador-dart",
+    "@sema/gerador-lua": "file:../gerador-lua",
+    "@sema/gerador-python": "file:../gerador-python",
+    "@sema/gerador-typescript": "file:../gerador-typescript",
+    "@sema/gerador-javascript": "file:../gerador-javascript",
+    "@sema/gerador-html": "file:../gerador-html",
+    "@sema/gerador-css": "file:../gerador-css",
+    "@sema/padroes": "file:../padroes",
     "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/gerador-javascript",
     "@sema/gerador-html",
-    "@sema/gerador-css",
-    "@sema/padroes"
+    "@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()];
+}