convez.ai
SkillSegurançaAvançado
babachat23da-maker

Auditor de Validação Silenciosa

babachat23da-maker/synthetic-calm-assertion

Detecta falhas silenciosas e código fake escondido em seu codebase

Ver no GitHub
InicialPluginScore · de 0 a 100

Skill de detecção de falhas silenciosas e código mock/stub em codebases. Funciona com dois pipelines paralelos: um que identifica funções que falham discretamente (retornos vazios, exceções engolidas) e outro que detecta código simulado ou placeholder. Gera relatório de risco com plano de remediação.

Instalação

$npx convez-ai babachat23da-maker/synthetic-calm-assertion

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
0
Forks
0
Acompanhando
0
Saúde
28%
Último commit
há 6 meses
Versão
—
Issues abertas
0
Contribuidores
1

Casos de uso

  • Auditoria de qualidade de código em produção
  • Identificação de implementações stub antes de deploy
  • CI/CD verificação de código genuíno vs mock
  • Análise de risco em bases legadas com código questionável

Veredito

Ferramenta niche e bem concebida para detectar antipadrões específicos de código desonesto. Útil em auditorias rigorosas, mas requer configuração cuidadosa e validação manual dos resultados para evitar falsos positivos.

README

A tradução para o português deste README ainda está na fila.

Silent Validation Auditor: The Stealth Pattern Detection Toolkit for Code Integrity Failures

Download

Identify, catalog, and eradicate silent failures, mock code, stub implementations, and placeholder logic from your codebase. The parallel-skill auditing framework for 2026.


Why Silent Validation Matters in 2026

Every codebase harbors ghosts. Not bugs that crash—those are easy to find. The truly dangerous ghosts are the ones that pretend to work: functions that return empty arrays instead of throwing errors, API clients that return mock data in production, placeholder implementations that silently skip critical logic, and stub responses that mask underlying system failures.

The Silent Validation Auditor (SVA) is a dual-skill agent framework inspired by the principles of dishonest-code audit. It operates two parallel Claude-powered analysis pipelines: one that hunts for silent failures (code that fails quietly without signaling) and another that detects mock/stub/placeholder code (code that simulates functionality without delivering it).

This is not a linter. This is a behavioral profiler for dishonest code.


The Two Parallel Skills Explained

graph TB
    A[Codebase Input] --> B{Parallel Skill Router}
    B --> C[Skill 1: Silent Failure Detection]
    B --> D[Skill 2: Mock/Stub/Placeholder Detection]
    
    C --> C1[Null/empty return analysis]
    C --> C2[Error swallowing detection]
    C --> C3[Empty catch blocks]
    C --> C4[Default fallback without logging]
    
    D --> D1[Hardcoded mock data patterns]
    D --> D2[Stub function signatures]
    D --> D3[Placeholder TODO implementations]
    D --> D4[Fake API response builders]
    
    C1 --> E[Unified Audit Report]
    C2 --> E
    C3 --> E
    C4 --> E
    D1 --> E
    D2 --> E
    D3 --> E
    D4 --> E
    
    E --> F[Risk Scoring Engine]
    F --> G[Actionable Remediation Plan]

Example Profile Configuration

Create a .sva-config.yaml file in your repository root:

version: "2026.1"
project_name: "my-api-service"

skills:
  silent_failure:
    enabled: true
    depth: deep
    patterns:
      - "return null"
      - "return undefined"
      - "return empty"
      - "catch(e){}"
      - "catch(e) { /* ignore */ }"
      - ".then(() => {})"
    ignore_paths:
      - "node_modules/"
      - "vendor/"

  mock_stub_detection:
    enabled: true
    context_aware: true
    patterns:
      - "mock_"
      - "stub_"
      - "fake_"
      - "placeholder_"
      - "TODO: implement"
      - "FIXME: replace later"
      - "sample data"
      - "test data only"
    min_confidence_threshold: 0.75

output:
  format: html
  include_remediation: true
  interactive_report: true

compatibility:
  languages:
    - javascript
    - typescript
    - python
    - java
    - go
    - rust

Example Console Invocation

# Basic scan of current directory
npx silent-validation-auditor scan ./src

# Deep audit with parallel skills
npx silent-validation-auditor audit --skills all --output ./reports/audit-2026.html

# Continuous monitoring mode
npx silent-validation-auditor watch --config .sva-config.yaml --notify slack

# CI/CD integration
npx silent-validation-auditor ci --fail-on-critical --min-score 85

Operating System Compatibility

OSSupport StatusNotes
🐧 Linux (Ubuntu 22.04+)✅ Full SupportNative binary execution
🍏 macOS 14+ (Sonoma)✅ Full SupportM1/M2/M3 optimized
🪟 Windows 11✅ Full SupportWSL2 recommended for deep scans
🐧 Linux (RHEL 9+)✅ Full SupportContainerized deployment
🍏 macOS 13 (Ventura)⚠️ LimitedSome parallel features unavailable
🪟 Windows 10⚠️ LimitedRequires PowerShell 7+

Key Features

🚫 Silent Failure Detection Engine

The silent failure detection skill operates like a lie detector for your code. It doesn't just look for syntax—it analyzes control flow paths that lead to unhandled failures. Functions that return null or undefined instead of throwing exceptions are flagged with context. Empty catch blocks that swallow errors are highlighted with the exact line where the failure path diverges.

This skill understands twenty-three distinct failure-silencing patterns, including: implicit null propagation, empty array fallbacks that hide data loss, default value assignments that mask failed computations, and conditional chains that drop errors silently.

🎭 Mock/Stub/Placeholder Detection

The mock and stub detection skill is trained on thousands of real-world codebases to recognize the fingerprints of dishonest implementation. It distinguishes between legitimate testing mocks (in __tests__ directories) and production code that contains mock-like patterns.

The tool identifies placeholder code by analyzing function complexity, return value patterns, and comment metadata. A function that returns a hardcoded string with a comment saying "TODO: implement real logic" is not just a placeholder—it's a risk vector that the system flags with high severity.

🧠 Dual-Agent Parallel Processing

Unlike traditional static analysis tools that run a single pass, SVA operates two independent Claude-powered analysis agents in parallel. Each agent has specialized context windows and pattern recognition models. The Silent Failure Agent focuses on error handling, exception flows, and recovery paths. The Mock/Stub Agent concentrates on implementation completeness, code intent analysis, and behavioral authenticity.

Results from both agents are merged into a unified risk score that accounts for the interaction between failure types. A function that both swallows errors AND returns stub data receives a higher criticality score than either issue alone.

📊 Interactive Report Generation

The output is not a static PDF or a terminal dump—it's a fully interactive HTML report that includes:

  • Heatmaps showing the density of dishonest code across your codebase
  • Call graph visualizations that trace how silent failures propagate through your system
  • Remediation suggestions generated by Claude AI, tailored to your specific code patterns
  • One-click fix proposals for common patterns

🔌 API Integrations

OpenAI API Integration

Leverage OpenAI's models for additional analysis perspectives. The tool can send suspicious code snippets to GPT-4 Turbo or GPT-4o for secondary verification:

integrations:
  openai:
    api_key: ${OPENAI_API_KEY}
    model: gpt-4-turbo
    fallback_model: gpt-3.5-turbo
    max_tokens: 4096
    secondary_validation: true

Claude API Integration

Native integration with Anthropic's Claude API for the core analysis pipeline:

integrations:
  claude:
    api_key: ${ANTHROPIC_API_KEY}
    model: claude-3-opus-20240229
    agent_count: 2
    parallel_skills: true
    context_window: 100000

Additional Feature Highlights

🌐 Responsive UI Dashboard

The web-based dashboard adapts to any screen size. View your audit results on a 4K monitor, a laptop, or a tablet. The dashboard uses a dark mode by default (because real auditors work at night) with a light mode toggle for daytime reviews.

🌍 Multilingual Support

Analyze codebases in any language. The comment analysis engine understands English, Spanish, French, German, Japanese, Chinese, Korean, Russian, Arabic, and Hindi. Placeholder comments in any of these languages are detected and flagged.

🕐 24/7 Background Monitoring

Deploy SVA as a background service that continuously monitors your repository for new commits. Every push triggers an automatic audit that compares the new code against existing patterns. Get Slack, Discord, or email notifications when new dishonest code patterns appear.

⚡ Performance Optimizations

  • Incremental scanning (only analyze changed files)
  • Distributed analysis across multiple machines
  • Caching for repeated pattern matching
  • Parallel file processing with configurable thread count

Installation

Download

# Using npm (recommended)
npm install -g silent-validation-auditor

# Using yarn
yarn global add silent-validation-auditor

# Using Homebrew (macOS)
brew install silent-validation-auditor

# Docker
docker pull silent-validation-auditor:2026.1

Quick Start

# Initialize configuration
silent-validation-auditor init

# Run your first audit
silent-validation-auditor scan ./src --quick

# Generate interactive report
silent-validation-auditor report --open

# Set up continuous monitoring
silent-validation-auditor watch --config .sva-config.yaml

Project Structure

silent-validation-auditor/
├── src/
│   ├── skills/
│   │   ├── silent_failure_detector.py
│   │   └── mock_stub_detector.py
│   ├── agents/
│   │   ├── claude_agent.py
│   │   └── openai_agent.py
│   ├── reports/
│   │   ├── html_generator.py
│   │   └── pdf_generator.py
│   ├── watchers/
│   │   ├── git_watcher.py
│   │   └── file_watcher.py
│   └── integrations/
│       ├── slack_notifier.py
│       └── webhook_sender.py
├── config/
│   ├── default.yaml
│   └── advanced_profiles/
├── tests/
│   ├── unit/
│   └── integration/
├── examples/
│   ├── honest_code/
│   └── dishonest_code/
├── docs/
│   ├── api/
│   └── tutorials/
└── README.md

Use Cases

For Engineering Teams

Stop deploying software that works "most of the time." Identify the silent failure patterns that cause intermittent issues in production. Every stub function you find and replace reduces your incident response time by eliminating the "it works on my machine" class of bugs.

For Security Auditors

Mock data in production is a security vulnerability. Stub implementations can leak test credentials, sample API keys, or fake user data. SVA flags every instance where production code contains mock-like patterns.

For Code Reviewers

Reduce review time by 40% by letting SVA pre-screen pull requests for common dishonest code patterns. The tool generates a summary of suspicious code that requires human attention, allowing reviewers to focus on architecture and logic instead of hunting for null returns.

For Technical Debt Managers

Quantify your codebase's honesty. Track the "dishonest code score" over time. Set thresholds for acceptable levels of mock/stub patterns. Use the trend data to justify refactoring sprints to management.


Configuration Reference

ParameterTypeDefaultDescription
versionstring"2026.1"Configuration schema version
skills.silent_failure.enabledbooleantrueEnable silent failure detection
skills.silent_failure.depthstring"medium"Analysis depth: quick, medium, deep
skills.mock_stub_detection.context_awarebooleantrueConsider file context before flagging
skills.mock_stub_detection.min_confidencefloat0.7Minimum confidence score to flag
output.formatstring"html"Report format: html, json, pdf, terminal
output.interactive_reportbooleantrueGenerate interactive report
compatibility.languagesarrayallTarget languages for analysis

Disclaimer

Important: The Silent Validation Auditor is a tool for identifying code patterns that may indicate dishonest implementation. It does not replace human code review, security auditing, or quality assurance processes. The tool may produce false positives (flagging legitimate code) and false negatives (missing actual issues). Always verify findings manually before making changes to production systems.

The parallel-skill analysis uses AI models that may have inherent biases or limitations. Results should be considered as indicators, not definitive judgments. The developers are not responsible for decisions made based on the output of this tool.

Use at your own risk. Always maintain backups and version control before applying automated remediation suggestions.


License

This project is licensed under the MIT License - see the LICENSE file for details.


Contributing

Contributions are welcome, especially new patterns for silent failure detection and mock/stub identification. Submit a pull request with test cases for any new patterns you discover in real-world codebases.


Download

Silent Validation Auditor v2026.1 — Because honest code fails loudly

Ver o original no GitHub

Bom para

Relacionados