@mocoto/mahoraga 0.14.0 → 0.14.2

package/dist/analysts/rust/analysts/analyst-concurrency.js

@@ -1,7 +1,8 @@
+// SPDX-License-Identifier: MIT
 import { messages } from '../../../core/messages/index.js';
 import { createLineLookup, maskRustComments } from '../../../shared/helpers/index.js';
 import { criarAnalista, criarOcorrencia } from '../../../types/index.js';
-const disableEnv = process.env.MAHORAGA_DISABLE_PLUGIN_RUST === '1';
+const disableEnv = process.env.SUKUNA_DISABLE_PLUGIN_RUST === '1';
 function warn(message, relPath, line, nivel) {
     return criarOcorrencia({
         relPath,
@@ -16,6 +17,7 @@ function collectConcurrencyIssues(src, relPath) {
     const ocorrencias = [];
     const lineOf = createLineLookup(src).lineAt;
     const scan = maskRustComments(src);
+    // Mutex across await
     for (const match of scan.matchAll(/(\w+)\.lock\(\)\.unwrap\(\)/g)) {
         const line = lineOf(match.index);
         const afterLock = src.slice(match.index, match.index + 300);
@@ -23,6 +25,7 @@ function collectConcurrencyIssues(src, relPath) {
             ocorrencias.push(warn(messages.RustMensagens.mutexAcrossAwait, relPath, line, messages.SeverityNiveis.error));
         }
     }
+    // RwLock across await
     for (const match of scan.matchAll(/(\w+)\.(?:read|write)\(\)\.unwrap\(\)/g)) {
         const line = lineOf(match.index);
         const afterLock = src.slice(match.index, match.index + 300);
@@ -30,15 +33,18 @@ function collectConcurrencyIssues(src, relPath) {
             ocorrencias.push(warn('RwLock guard held across .await; potential deadlock', relPath, line, messages.SeverityNiveis.error));
         }
     }
+    // Arc::new without interior mutability consideration
     for (const match of scan.matchAll(/\bArc\s*::\s*new\s*\(/g)) {
         const line = lineOf(match.index);
         const snippet = src.slice(match.index, match.index + 200);
-        if (snippet.includes('Mutex') || snippet.includes('RwLock') || snippet.includes('Atomic'))
+        if (snippet.includes('Mutex') || snippet.includes('RwLock') || snippet.includes('Atomic')) {
             continue;
+        }
         if (snippet.match(/Arc::new\([^)]*\)/) && !snippet.includes('Mutex') && !snippet.includes('RwLock')) {
             ocorrencias.push(warn('Arc::new() wrapping non-atomic type; consider Mutex or RwLock for interior mutability', relPath, line, messages.SeverityNiveis.suggestion));
         }
     }
+    // spawn without JoinHandle
     for (const match of scan.matchAll(/\bthread::spawn\s*\(/g)) {
         const line = lineOf(match.index);
         const srcBefore = src.slice(0, match.index);
@@ -55,11 +61,11 @@ export const analistaRustConcorrencia = criarAnalista({
     descricao: 'Detecta problemas de concorrência em código Rust.',
     global: false,
     test: (relPath) => /\.(rs)$/i.test(relPath),
-    aplicar: async (src, relPath) => {
-        if (disableEnv)
+    aplicar: (src, relPath) => {
+        if (disableEnv) {
             return null;
+        }
         const msgs = collectConcurrencyIssues(src, relPath);
         return msgs.length ? msgs : null;
     }
 });
-//# sourceMappingURL=analyst-concurrency.js.map

package/dist/analysts/rust/analysts/analyst-memory.js

@@ -1,7 +1,8 @@
+// SPDX-License-Identifier: MIT
 import { messages } from '../../../core/messages/index.js';
 import { createLineLookup, maskRustComments } from '../../../shared/helpers/index.js';
 import { criarAnalista, criarOcorrencia } from '../../../types/index.js';
-const disableEnv = process.env.MAHORAGA_DISABLE_PLUGIN_RUST === '1';
+const disableEnv = process.env.SUKUNA_DISABLE_PLUGIN_RUST === '1';
 function warn(message, relPath, line, nivel) {
     return criarOcorrencia({
         relPath,
@@ -16,22 +17,25 @@ function collectMemoryIssues(src, relPath) {
     const ocorrencias = [];
     const lineOf = createLineLookup(src).lineAt;
     const scan = maskRustComments(src);
+    // Vec without with_capacity
     for (const match of scan.matchAll(/(\w+)\.push\(/g)) {
         const line = lineOf(match.index);
-        const varName = match[1] ?? '';
+        const varName = match[1];
         const declMatch = new RegExp(`let\\s+mut\\s+${varName}\\s*:\\s*Vec|<|=\\s*Vec::new\\(\\)`, 'i');
         if (declMatch.test(scan.slice(0, match.index))) {
             ocorrencias.push(warn(messages.RustMensagens.vecWithoutCapacity, relPath, line, messages.SeverityNiveis.suggestion));
         }
     }
+    // read_line without trimming
     for (const match of scan.matchAll(/(\w+)\.read_line\(&mut\s+(\w+)\)/g)) {
         const line = lineOf(match.index);
-        const varName = match[2] ?? '';
+        const varName = match[2];
         const snippet = src.slice(match.index, match.index + 200);
         if (!snippet.includes(`${varName}.trim()`) && !snippet.includes(`${varName}.trim_end()`)) {
             ocorrencias.push(warn(messages.RustMensagens.noTrimOnInput, relPath, line));
         }
     }
+    // Box::new on large stack allocation
     for (const match of scan.matchAll(/\bBox::new\s*\(([^)]{0,20})\)/g)) {
         const line = lineOf(match.index);
         const inner = match[1];
@@ -39,6 +43,7 @@ function collectMemoryIssues(src, relPath) {
             ocorrencias.push(warn('Box::new with inline allocation; consider using Box::new only for heap allocation', relPath, line, messages.SeverityNiveis.info));
         }
     }
+    // String allocation with + operator in loop
     for (const match of scan.matchAll(/for\s+\w+\s+in\s+[\s\S]{0,200}\{[\s\S]{0,500}\w+\s*\+=\s*["'`]/gi)) {
         const line = lineOf(match.index);
         ocorrencias.push(warn('String concatenation in loop; use String::with_capacity and push_str', relPath, line, messages.SeverityNiveis.suggestion));
@@ -51,11 +56,11 @@ export const analistaRustMemoria = criarAnalista({
     descricao: 'Detecta problemas de alocação e gerenciamento de memória em código Rust.',
     global: false,
     test: (relPath) => /\.(rs)$/i.test(relPath),
-    aplicar: async (src, relPath) => {
-        if (disableEnv)
+    aplicar: (src, relPath) => {
+        if (disableEnv) {
             return null;
+        }
         const msgs = collectMemoryIssues(src, relPath);
         return msgs.length ? msgs : null;
     }
 });
-//# sourceMappingURL=analyst-memory.js.map

package/dist/analysts/rust/analysts/analyst-rust.js

@@ -1,7 +1,8 @@
+// SPDX-License-Identifier: MIT
 import { messages } from '../../../core/messages/index.js';
 import { createLineLookup, maskRustComments } from '../../../shared/helpers/index.js';
 import { criarAnalista, criarOcorrencia } from '../../../types/index.js';
-const disableEnv = process.env.MAHORAGA_DISABLE_PLUGIN_RUST === '1';
+const disableEnv = process.env.SUKUNA_DISABLE_PLUGIN_RUST === '1';
 function isRustFile(relPath) {
     return /\.(rs)$/i.test(relPath);
 }
@@ -51,19 +52,70 @@ function collectGeneralRustIssues(src, relPath) {
     if (maxDepth > 8) {
         ocorrencias.push(warn(`Deep nesting detected (${maxDepth} levels); consider refactoring`, relPath, 1, messages.SeverityNiveis.suggestion));
     }
+    // detect Lazy/OnceCell from once_cell crate -> suggest std::sync::LazyLock (Rust 1.80+)
+    for (const match of scan.matchAll(/\b(once_cell::sync::Lazy|once_cell::sync::OnceCell)\b/g)) {
+        const line = lineOf(match.index);
+        const isLazy = match[1].includes('Lazy');
+        ocorrencias.push(warn(isLazy
+            ? `'once_cell::sync::Lazy' detected; use std::sync::LazyLock (stable since Rust 1.80)`
+            : `'once_cell::sync::OnceCell' detected; use std::sync::OnceLock (stable since Rust 1.70)`, relPath, line, messages.SeverityNiveis.suggestion));
+    }
+    // detect manual offset calculation -> suggest std::mem::offset_of! (Rust 1.77+)
+    for (const match of scan.matchAll(/offset_of!\(/g)) {
+        const line = lineOf(match.index);
+        ocorrencias.push(warn('offset_of! macro usage is correct for Rust 1.77+', relPath, line, messages.SeverityNiveis.info));
+    }
+    // detect manual transmute-like offset patterns
+    for (const match of scan.matchAll(/(\w+) as \*const u8\)\.offset\((\d+)\)/g)) {
+        const line = lineOf(match.index);
+        ocorrencias.push(warn('Manual pointer offset for field access; consider std::mem::offset_of! (Rust 1.77+)', relPath, line, messages.SeverityNiveis.suggestion));
+    }
+    // detect assert!(matches!(...)) -> suggest assert_matches! (Rust 1.81+)
+    for (const match of scan.matchAll(/assert!\(matches!\(/g)) {
+        const line = lineOf(match.index);
+        ocorrencias.push(warn('assert!(matches!(...)) pattern; consider assert_matches!(...) (unstable, nightly only)', relPath, line, messages.SeverityNiveis.info));
+    }
+    // detect if let ... && let ... (let_chains, stable since Rust 1.78)
+    for (const match of scan.matchAll(/if\s+let\s+\w+\s*=\s*\w+\s*&&\s*let\s+/g)) {
+        const line = lineOf(match.index);
+        ocorrencias.push(warn('let_chains pattern detected (stable since Rust 1.78)', relPath, line, messages.SeverityNiveis.info));
+    }
+    // detect is_some_and / is_ok_and (stable since Rust 1.70)
+    for (const match of scan.matchAll(/\.is_some\(\)\s*&&\s*\w+\s*==/g)) {
+        const line = lineOf(match.index);
+        ocorrencias.push(warn('.is_some() && predicate pattern; consider .is_some_and(|x| ...) (Rust 1.70+)', relPath, line, messages.SeverityNiveis.suggestion));
+    }
+    for (const match of scan.matchAll(/\.is_ok\(\)\s*&&\s*\w+\s*==/g)) {
+        const line = lineOf(match.index);
+        ocorrencias.push(warn('.is_ok() && predicate pattern; consider .is_ok_and(|x| ...) (Rust 1.70+)', relPath, line, messages.SeverityNiveis.suggestion));
+    }
+    // detect Option::inspect / Result::inspect (stable since Rust 1.76)
+    for (const match of scan.matchAll(/\.map\(.*\|x\|.*\{[\s\S]{0,100}println!.*\}\)/g)) {
+        const line = lineOf(match.index);
+        ocorrencias.push(warn('map() with side-effect closure; consider .inspect() (Rust 1.76+)', relPath, line, messages.SeverityNiveis.suggestion));
+    }
+    // detect string interpolation for format args (Rust 1.80+)
+    for (const match of scan.matchAll(/format!\(["']\{[\w:?]*\}["'],\s*(\w+)\)/g)) {
+        const line = lineOf(match.index);
+        const varName = match[1];
+        if (varName !== match[0].match(/\{(\w+)\}/)?.[1]) {
+            // suggest captured identifier format
+            ocorrencias.push(warn(`format!("{varName}") could be simplified to format!("{varName}") using captured identifiers (Rust 1.80+)`, relPath, line, messages.SeverityNiveis.info));
+        }
+    }
     return ocorrencias;
 }
 export const analistaRust = criarAnalista({
     nome: 'analista-rust',
     categoria: 'linguagem',
-    descricao: 'Analisa código Rust em busca de convenções de nomenclatura e organização.',
+    descricao: 'Analisa código Rust: convenções, nomenclatura, padrões modernos (edition 2024).',
     global: false,
     test: (relPath) => isRustFile(relPath),
-    aplicar: async (src, relPath) => {
-        if (disableEnv)
+    aplicar: (src, relPath) => {
+        if (disableEnv) {
             return null;
+        }
         const msgs = collectGeneralRustIssues(src, relPath);
         return msgs.length ? msgs : null;
     }
 });
-//# sourceMappingURL=analyst-rust.js.map

package/dist/analysts/rust/analysts/analyst-security.js

@@ -1,7 +1,8 @@
+// SPDX-License-Identifier: MIT
 import { messages } from '../../../core/messages/index.js';
 import { createLineLookup, maskRustComments } from '../../../shared/helpers/index.js';
 import { criarAnalista, criarOcorrencia } from '../../../types/index.js';
-const disableEnv = process.env.MAHORAGA_DISABLE_PLUGIN_RUST === '1';
+const disableEnv = process.env.SUKUNA_DISABLE_PLUGIN_RUST === '1';
 function warn(message, relPath, line, nivel) {
     return criarOcorrencia({
         relPath,
@@ -16,46 +17,81 @@ function collectSecurityIssues(src, relPath) {
     const ocorrencias = [];
     const lineOf = createLineLookup(src).lineAt;
     const scan = maskRustComments(src);
+    // unwrap() in production code
     for (const match of scan.matchAll(/\.unwrap\(\)/g)) {
         const line = lineOf(match.index);
         ocorrencias.push(warn(messages.RustMensagens.unwrapUsage, relPath, line, messages.SeverityNiveis.error));
     }
+    // expect() with empty message
     for (const match of scan.matchAll(/\.expect\(\)/g)) {
         const line = lineOf(match.index);
         ocorrencias.push(warn(messages.RustMensagens.emptyExpect, relPath, line));
     }
+    // unsafe blocks
     for (const match of scan.matchAll(/\bunsafe\s*\{/g)) {
         const line = lineOf(match.index);
         ocorrencias.push(warn(messages.RustMensagens.unsafeBlock, relPath, line, messages.SeverityNiveis.error));
     }
+    // transmute usage
     for (const match of scan.matchAll(/\b(?:std::)?mem::transmute\b/g)) {
         const line = lineOf(match.index);
         ocorrencias.push(warn(messages.RustMensagens.transmuteUsage, relPath, line, messages.SeverityNiveis.error));
     }
+    // Hardcoded secrets
     for (const match of scan.matchAll(/(?:password|secret|api[_-]?key|token|credential|senha)\s*(?::\s*|=\s*["'`])([^"'`\s]{4,})/gi)) {
         const line = lineOf(match.index);
         const value = match[1];
-        if (value.includes('env!') || value.includes('env::var'))
+        if (value.includes('env!') || value.includes('env::var')) {
             continue;
+        }
         ocorrencias.push(warn(messages.RustMensagens.hardcodedSecret, relPath, line, messages.SeverityNiveis.error));
     }
+    // unsafe trait implementation
     for (const match of scan.matchAll(/\bunsafe\s+(?:trait|impl|fn)\b/g)) {
         const line = lineOf(match.index);
         ocorrencias.push(warn(`Unsafe ${match[1]} declaration; document safety invariants with // SAFETY:`, relPath, line, messages.SeverityNiveis.error));
     }
+    // pointer::cast instead of `as` pointer cast (Rust 1.72+)
+    for (const match of scan.matchAll(/\b(\w+)\s+as\s+\*const\s+\w+/g)) {
+        const line = lineOf(match.index);
+        if (!match[0].includes('as *const u8')) {
+            ocorrencias.push(warn('Using `as` for pointer cast; consider .pointer::cast::<T>() or .cast() (Rust 1.72+)', relPath, line, messages.SeverityNiveis.suggestion));
+        }
+    }
+    // Command::new with shell injection risk
+    for (const match of scan.matchAll(/Command::new\(["'](sh|bash|cmd|powershell)["']\)/g)) {
+        const line = lineOf(match.index);
+        const argsMatch = src.slice(match.index, match.index + 200).match(/\.arg\(/);
+        if (argsMatch) {
+            ocorrencias.push(warn('Shell invocation via Command; ensure no injection via user input', relPath, line, messages.SeverityNiveis.error));
+        }
+    }
+    // detect .ok()?.unwrap() antipattern
+    for (const match of scan.matchAll(/\.ok\(\)\?\.unwrap\(\)/g)) {
+        const line = lineOf(match.index);
+        ocorrencias.push(warn('.ok()?.unwrap() antipattern; use ? directly on Result instead', relPath, line, messages.SeverityNiveis.warning));
+    }
+    // detect splitn / split_once with manual index access instead of destructuring (Rust 1.62+ split_once stable)
+    for (const match of scan.matchAll(/\.splitn\(2,\s*/g)) {
+        const line = lineOf(match.index);
+        const afterSplit = src.slice(match.index, match.index + 100);
+        if (afterSplit.includes('[0]') || afterSplit.includes('[1]')) {
+            ocorrencias.push(warn('splitn(2, ...) with index access; consider .split_once() for cleaner destructuring (Rust 1.62+)', relPath, line, messages.SeverityNiveis.suggestion));
+        }
+    }
     return ocorrencias;
 }
 export const analistaRustSeguranca = criarAnalista({
     nome: 'analista-rust-seguranca',
     categoria: 'seguranca',
-    descricao: 'Detecta problemas de segurança e unsafe em código Rust.',
+    descricao: 'Detecta problemas de segurança e unsafe em Rust (edition 2024).',
     global: false,
     test: (relPath) => /\.(rs)$/i.test(relPath),
-    aplicar: async (src, relPath) => {
-        if (disableEnv)
+    aplicar: (src, relPath) => {
+        if (disableEnv) {
             return null;
+        }
         const msgs = collectSecurityIssues(src, relPath);
         return msgs.length ? msgs : null;
     }
 });
-//# sourceMappingURL=analyst-security.js.map

package/dist/analysts/rust/analysts/index.js

@@ -1,6 +1,6 @@
+// SPDX-License-Identifier: MIT
 export * from './analyst-best-practices.js';
 export * from './analyst-concurrency.js';
 export * from './analyst-memory.js';
 export * from './analyst-rust.js';
 export * from './analyst-security.js';
-//# sourceMappingURL=index.js.map

package/dist/analysts/rust/detectors/detector-conventions.js

@@ -1,11 +1,13 @@
+// SPDX-License-Identifier: MIT
 import { messages } from '../../../core/messages/index.js';
 import { createLineLookup, maskRustComments } from '../../../shared/helpers/index.js';
 import { criarAnalista } from '../../../types/index.js';
-const disableEnv = process.env.MAHORAGA_DISABLE_PLUGIN_RUST === '1';
+const disableEnv = process.env.SUKUNA_DISABLE_PLUGIN_RUST === '1';
 function detectConventions(src, relPath) {
     const ocorrencias = [];
     const lineOf = createLineLookup(src).lineAt;
     const scan = maskRustComments(src);
+    // Pub function missing doc comment
     for (const match of scan.matchAll(/^\s*pub\s+fn\s+(\w+)/gm)) {
         const fnName = match[1];
         const srcBefore = src.slice(0, match.index);
@@ -24,6 +26,7 @@ function detectConventions(src, relPath) {
             });
         }
     }
+    // Const naming: SCREAMING_CASE
     for (const match of scan.matchAll(/^\s*(?:pub\s+)?(?:const)\s+(\w+)\s*:/gm)) {
         const constName = match[1];
         if (/[a-z]/.test(constName)) {
@@ -38,6 +41,7 @@ function detectConventions(src, relPath) {
             });
         }
     }
+    // Use of `return` keyword at end of function (redundant)
     for (const match of scan.matchAll(/\breturn\s+(\w[\w!]*)\s*;$/gm)) {
         const line = lineOf(match.index);
         const fnContext = src.slice(0, match.index).match(/\bfn\s+\w+\s*\(/g);
@@ -55,6 +59,7 @@ function detectConventions(src, relPath) {
             }
         }
     }
+    // Wildcard imports (use of *)
     for (const match of scan.matchAll(/\buse\s+(?:\w+::)+\*\s*;/g)) {
         const line = lineOf(match.index);
         const importPath = match[0].replace('use ', '').replace(';', '');
@@ -75,11 +80,11 @@ export const detectorConvencoes = criarAnalista({
     descricao: 'Verifica conformidade com convenções de código Rust.',
     global: false,
     test: (relPath) => /\.(rs)$/i.test(relPath),
-    aplicar: async (src, relPath) => {
-        if (disableEnv)
+    aplicar: (src, relPath) => {
+        if (disableEnv) {
             return null;
+        }
         const msgs = detectConventions(src, relPath);
         return msgs.length ? msgs : null;
     }
 });
-//# sourceMappingURL=detector-conventions.js.map

package/dist/analysts/rust/detectors/detector-errors-potential.js

@@ -1,11 +1,13 @@
+// SPDX-License-Identifier: MIT
 import { messages } from '../../../core/messages/index.js';
 import { createLineLookup, maskRustComments } from '../../../shared/helpers/index.js';
 import { criarAnalista } from '../../../types/index.js';
-const disableEnv = process.env.MAHORAGA_DISABLE_PLUGIN_RUST === '1';
+const disableEnv = process.env.SUKUNA_DISABLE_PLUGIN_RUST === '1';
 function detectPotentialErrors(src, relPath) {
     const ocorrencias = [];
     const lineOf = createLineLookup(src).lineAt;
     const scan = maskRustComments(src);
+    // unwrap() with context: check if inside a function returning Result
     for (const match of scan.matchAll(/\.unwrap\(\)/g)) {
         const line = lineOf(match.index);
         const fnContext = src.slice(0, match.index).match(/\bfn\s+\w+[\s\S]{0,200}$/);
@@ -22,6 +24,7 @@ function detectPotentialErrors(src, relPath) {
             tipo: 'rust/rule'
         });
     }
+    // expect() with empty or generic message
     for (const match of scan.matchAll(/\.expect\(\)/g)) {
         const line = lineOf(match.index);
         ocorrencias.push({
@@ -44,6 +47,7 @@ function detectPotentialErrors(src, relPath) {
             tipo: 'rust/rule'
         });
     }
+    // Panic macros that should be avoided in production
     for (const match of scan.matchAll(/\b(unreachable!|unimplemented!)\s*\(/g)) {
         const line = lineOf(match.index);
         ocorrencias.push({
@@ -55,6 +59,7 @@ function detectPotentialErrors(src, relPath) {
             tipo: 'rust/rule'
         });
     }
+    // detect panic macro
     for (const match of scan.matchAll(/\btodo!\s*\(/g)) {
         const line = lineOf(match.index);
         ocorrencias.push({
@@ -74,11 +79,11 @@ export const detectorErrosPotenciais = criarAnalista({
     descricao: 'Detecta padrões de erro potencial em código Rust.',
     global: false,
     test: (relPath) => /\.(rs)$/i.test(relPath),
-    aplicar: async (src, relPath) => {
-        if (disableEnv)
+    aplicar: (src, relPath) => {
+        if (disableEnv) {
             return null;
+        }
         const msgs = detectPotentialErrors(src, relPath);
         return msgs.length ? msgs : null;
     }
 });
-//# sourceMappingURL=detector-errors-potential.js.map

package/dist/analysts/rust/detectors/detector-unsafe.js

@@ -1,16 +1,18 @@
+// SPDX-License-Identifier: MIT
 import { messages } from '../../../core/messages/index.js';
 import { createLineLookup, maskRustComments } from '../../../shared/helpers/index.js';
 import { criarAnalista } from '../../../types/index.js';
-const disableEnv = process.env.MAHORAGA_DISABLE_PLUGIN_RUST === '1';
+const disableEnv = process.env.SUKUNA_DISABLE_PLUGIN_RUST === '1';
 function detectUnsafePatterns(src, relPath) {
     const ocorrencias = [];
     const lineOf = createLineLookup(src).lineAt;
     const scan = maskRustComments(src);
+    // unsafe blocks without SAFETY comment
     for (const match of scan.matchAll(/\bunsafe\s*\{/g)) {
         const line = lineOf(match.index);
         const srcBefore = src.slice(0, match.index);
         const lineStart = srcBefore.lastIndexOf('\n') + 1;
-        const lineText = src.slice(lineStart, match.index).trim();
+        const _lineText = src.slice(lineStart, match.index).trim();
         const precedingLines = src.split('\n').slice(Math.max(0, line - 4), line).join('\n');
         if (!precedingLines.includes('// SAFETY:') && !precedingLines.includes('/* SAFETY:')) {
             ocorrencias.push({
@@ -23,6 +25,7 @@ function detectUnsafePatterns(src, relPath) {
             });
         }
     }
+    // transmute without comment
     for (const match of scan.matchAll(/\b(?:std::)?mem::transmute\b/g)) {
         const line = lineOf(match.index);
         const srcBefore = src.slice(0, match.index);
@@ -38,6 +41,7 @@ function detectUnsafePatterns(src, relPath) {
             });
         }
     }
+    // pointer dereference in safe code
     for (const match of scan.matchAll(/\b(?:const|mut)\s+ptr\s*:\s*\*/g)) {
         const line = lineOf(match.index);
         const srcAfter = src.slice(match.index, match.index + 200);
@@ -52,6 +56,7 @@ function detectUnsafePatterns(src, relPath) {
             });
         }
     }
+    // #[repr(C)] without proper justification
     for (const match of scan.matchAll(/#\[repr\(C\)\]/g)) {
         const line = lineOf(match.index);
         const srcBefore = src.slice(0, match.index);
@@ -75,11 +80,11 @@ export const detectorUnsafe = criarAnalista({
     descricao: 'Detecta uso inadequado de unsafe e operações inseguras em código Rust.',
     global: false,
     test: (relPath) => /\.(rs)$/i.test(relPath),
-    aplicar: async (src, relPath) => {
-        if (disableEnv)
+    aplicar: (src, relPath) => {
+        if (disableEnv) {
             return null;
+        }
         const msgs = detectUnsafePatterns(src, relPath);
         return msgs.length ? msgs : null;
     }
 });
-//# sourceMappingURL=detector-unsafe.js.map

package/dist/analysts/rust/detectors/index.js

@@ -1,4 +1,4 @@
+// SPDX-License-Identifier: MIT
 export * from './detector-conventions.js';
 export * from './detector-errors-potential.js';
 export * from './detector-unsafe.js';
-//# sourceMappingURL=index.js.map

package/dist/analysts/rust/index.js

@@ -1,3 +1,3 @@
+// SPDX-License-Identifier: MIT
 export * from './analysts/index.js';
 export * from './detectors/index.js';
-//# sourceMappingURL=index.js.map

package/dist/analysts/scorers/index.js

@@ -1,2 +1,5 @@
+// SPDX-License-Identifier: MIT
+/**
+ * @fileoverview Pontuadores (scorers) for analysis
+ */
 export * from './scorer.js';
-//# sourceMappingURL=index.js.map