From 0f2694136753d7e7f68c3ecbf9790157039f50b8 Mon Sep 17 00:00:00 2001
From: Einswilli <wilfriedgoeh@gmail.com>
Date: Sat, 6 Sep 2025 15:02:56 +0000
Subject: [PATCH 01/17] Add Lint & format workflows.

---
 .github/workflows/lint-format.yml | 35 +++++++++++++++++++++++++++++++
 1 file changed, 35 insertions(+)
 create mode 100644 .github/workflows/lint-format.yml

diff --git a/.github/workflows/lint-format.yml b/.github/workflows/lint-format.yml
new file mode 100644
index 0000000..836c676
--- /dev/null
+++ b/.github/workflows/lint-format.yml
@@ -0,0 +1,35 @@
+name: Lint & Format
+
+on:
+  push:
+    branches: [master]
+  pull_request:
+    branches: [master]
+
+jobs:
+  lint-format:
+    name: Lint, Format, and Type Check
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout code
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: '3.12'
+
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install black isort mypy
+
+      - name: Run black
+        run: black .
+
+      - name: Run isort
+        run: isort .
+
+    #   - name: Run mypy
+    #     run: mypy .

From b9913ca90305aac7eb59bd281f33b2c0610538f6 Mon Sep 17 00:00:00 2001
From: Einswilli <wilfriedgoeh@gmail.com>
Date: Sat, 6 Sep 2025 17:17:30 +0000
Subject: [PATCH 02/17] Add Code of Conduct.

---
 .gitignore         |  9 ++++++++-
 .python-version    |  1 +
 CODE_OF_CONDUCT.md | 43 +++++++++++++++++++++++++++++++++++++++++++
 main.py            |  6 ++++++
 pyproject.toml     | 37 +++++++++++++++++++++++++++++++++++++
 5 files changed, 95 insertions(+), 1 deletion(-)
 create mode 100644 .python-version
 create mode 100644 CODE_OF_CONDUCT.md
 create mode 100644 main.py
 create mode 100644 pyproject.toml

diff --git a/.gitignore b/.gitignore
index b7faf40..ae29df6 100644
--- a/.gitignore
+++ b/.gitignore
@@ -98,7 +98,7 @@ ipython_config.py
 #   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
 #   This is especially recommended for binary packages to ensure reproducibility, and is more
 #   commonly ignored for libraries.
-#uv.lock
+uv.lock
 
 # poetry
 #   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
@@ -205,3 +205,10 @@ cython_debug/
 marimo/_static/
 marimo/_lsp/
 __marimo__/
+
+
+# CUSTOM
+docs/*
+rules/*
+tests/*
+valkyrie/*
diff --git a/.python-version b/.python-version
new file mode 100644
index 0000000..24ee5b1
--- /dev/null
+++ b/.python-version
@@ -0,0 +1 @@
+3.13
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
new file mode 100644
index 0000000..ab6d481
--- /dev/null
+++ b/CODE_OF_CONDUCT.md
@@ -0,0 +1,43 @@
+# 🕊 **Valkyrie Code of Conduct**
+
+## 🌟 Our Pledge  
+We pledge to foster an open, inclusive, and respectful environment for all contributors, regardless of:  
+
+- Background or experience level  
+- Gender identity or expression  
+- Sexual orientation  
+- Disability  
+- Personal appearance  
+- Race, ethnicity, or religion  
+- Technology preferences  
+
+## 🚫 Unacceptable Behavior  
+Examples include but are not limited to:  
+
+- Harassment or derogatory comments  
+- Trolling or personal/political attacks  
+- Publishing others' private information without consent  
+- Other conduct that could reasonably be considered inappropriate  
+
+## 🛠 Enforcement Responsibilities  
+Project maintainers will:  
+
+- Remove/edit inappropriate content  
+- Warn or ban offenders temporarily/permanently  
+- Apply consequences fairly and consistently  
+
+## ⚖️ Reporting Guidelines  
+Report violations to **[project email/contact]** with:  
+
+1. **Where/when** the incident occurred  
+2. **Description** of the behavior  
+3. **Context** (if available)  
+4. Your **contact information** (optional)  
+
+All reports will be reviewed and investigated promptly.  
+
+## 🔄 Attribution  
+This Code of Conduct is adapted from:  
+
+- [Contributor Covenant 2.1](https://www.contributor-covenant.org/)  
+- [Django Code of Conduct](https://www.djangoproject.com/conduct/)  
diff --git a/main.py b/main.py
new file mode 100644
index 0000000..addd523
--- /dev/null
+++ b/main.py
@@ -0,0 +1,6 @@
+def main():
+    print("Hello from valkyrie!")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/pyproject.toml b/pyproject.toml
new file mode 100644
index 0000000..f0c833d
--- /dev/null
+++ b/pyproject.toml
@@ -0,0 +1,37 @@
+[project]
+name = "valkyrie"
+version = "0.1.0"
+description = "The guardian of your Pull Requests. She decides what gets to merge."
+readme = "README.md"
+license = {file = "LICENSE"}
+authors = [{ name = "AllDotPy", email = "hello@alldotpy.com" }]
+maintainers = [{ name = "#Einswilli", email = "einswilligoeh@email.com" }]
+requires-python = ">=3.13"
+dependencies = []
+
+[project.optional-dependencies]
+dev = [
+    "black", 
+    "mypy",
+    "twine",
+    "uv",
+    "build",
+    "pytest>=8.4.0", 
+    "mkdocs>=1.6.1",
+    "setuptools>=80.8.0",
+    "mkdocs-material>=9.6.14",
+    "mkdocs-static-i18n>=1.3.0",
+]
+
+[project.urls]
+Homepage = "https://alldotpy.github.io/FletX"
+Repository = "https://github.com/AllDotPy/FletX"
+Documentation = "https://alldotpy.github.io/FletX"
+Tracker = "https://github.com/AllDotPy/FletX/issues"
+
+[tool.setuptools]
+packages = ["valkyrie"]
+
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
\ No newline at end of file

From b6bd2620f79a0631a979d9b7873d253dc0ef79f8 Mon Sep 17 00:00:00 2001
From: Einswilli <wilfriedgoeh@gmail.com>
Date: Sat, 6 Sep 2025 17:27:55 +0000
Subject: [PATCH 03/17] Add Contributions guide.

---
 CONTRIBUTING.md | 330 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 330 insertions(+)
 create mode 100644 CONTRIBUTING.md

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
new file mode 100644
index 0000000..bba36bf
--- /dev/null
+++ b/CONTRIBUTING.md
@@ -0,0 +1,330 @@
+# 🛡️ Valkyrie - Contribution Guide
+
+Thank you for your interest in contributing to Valkyrie! This guide will help you get started with the project.
+
+## 📋 Table of Contents
+1. [Getting Started](#getting-started)
+2. [Project Structure](#project-structure)
+3. [Development Workflow](#development-workflow)
+4. [Code Conventions](#code-conventions)
+5. [Testing & Quality](#testing--quality)
+6. [Documentation](#documentation)
+7. [Reporting Bugs](#reporting-bugs)
+8. [Feature Proposals](#feature-proposals)
+9. [Code of Conduct](#code-of-conduct)
+
+---
+
+## 1. Getting Started <a name="getting-started"></a>
+
+### Prerequisites
+- Python 3.10+
+- Git
+- Poetry (for dependency management)
+
+### Initial Setup
+```bash
+# Fork the repository
+git clone https://github.com/AllDotPy/valkyrie.git
+cd valkyrie
+
+# Install dependencies
+poetry install
+
+# Install pre-commit hooks
+poetry run pre-commit install
+
+# Verify installation
+poetry run valkyrie --version
+```
+
+### Development Environment
+We recommend using VS Code with the following extensions:
+- Python
+- Pylance
+- Ruff
+- Pre-commit
+
+---
+
+## 2. Project Structure <a name="project-structure"></a>
+
+```
+valkyrie/
+├── valkyrie/
+│   ├── core/
+│   │   ├── scanner.py          # Main Engine 
+│   │   ├── types.py            # Common Types
+│   │   └── exceptions.py       # Custom Exceptions 
+│   ├── plugins/
+│   │   ├── __init__.py         # Plugin manager
+│   │   ├── secrets.py          # Plugin secrets
+│   │   ├── dependencies.py     # Plugin deps
+│   │   └── iam.py              # Plugin IAM
+│   ├── integrations/
+│   │   ├── github.py           # GitHub Actions
+│   │   ├── gitlab.py           # GitLab CI
+│   │   └── formatters.py       # SARIF, HTML, etc.
+│   └── cli.py                  # CLI Interface
+├── rules/                      # Local Rules
+├── tests/                      # Comprehensive test suite
+├── docs/                       # Documentation
+├── .github/workflows/          # GitHub Actions
+├── valkyrie.yaml              # Configuration
+├── pyproject.toml             # Python packaging
+└── README.md                  # Documentation utilisateur
+```
+
+---
+
+## 3. Development Workflow <a name="development-workflow"></a>
+
+### Branch Strategy
+- `main` - Stable production branch
+- `develop` - Integration branch for features
+- `feature/*` - New features
+- `fix/*` - Bug fixes
+- `docs/*` - Documentation improvements
+
+### Contribution Process
+1. **Find an Issue** - Look for `good first issue` or `help wanted` labels
+2. **Discuss** - Comment on the issue to discuss approach
+3. **Branch** - Create a feature branch from `develop`
+4. **Code** - Implement your changes
+5. **Test** - Add tests and ensure they pass
+6. **Commit** - Use conventional commit messages
+7. **PR** - Open a pull request against `develop`
+
+### Commit Message Convention
+```
+<type>(<scope>): <subject>
+
+<body>
+
+<footer>
+```
+
+**Types**: `feat`, `fix`, `docs`, `style`, `refactor`, `test`, `chore`
+
+**Example**:
+```
+feat(scanner): add AWS secret detection
+
+- Implement regex pattern for AWS access keys
+- Add whitelist for common false positives
+- Include comprehensive tests
+
+Closes #123
+```
+
+---
+
+## 4. Code Conventions <a name="code-conventions"></a>
+
+### Python Style
+- Follow PEP 8 guidelines
+- Use type hints extensively
+- Maximum line length: 100 characters
+- Use Google-style docstrings
+
+**Example**:
+```python
+def scan_file(file_path: Path, rules: List[Rule]) -> List[Finding]:
+    """Scan a single file against provided rules.
+    
+    Args:
+        file_path: Path to the file to scan
+        rules: List of rules to apply
+        
+    Returns:
+        List of findings discovered in the file
+        
+    Raises:
+        FileNotFoundError: If the file doesn't exist
+        PermissionError: If unable to read the file
+    """
+    # Implementation
+```
+
+### Import Organization
+```python
+# Standard library
+import os
+import re
+from pathlib import Path
+from typing import List, Optional
+
+# Third-party
+import requests
+from pydantic import BaseModel
+
+# Local imports
+from valkyrie.domain.entities import Finding
+from valkyrie.domain.rules import Rule
+```
+
+---
+
+## 5. Testing & Quality <a name="testing--quality"></a>
+
+### Running Tests
+```bash
+# Run all tests
+poetry run pytest
+
+# Run with coverage
+poetry run pytest --cov=valkyrie
+
+# Run specific test
+poetry run pytest tests/domain/test_rules.py -v
+
+# Run linting
+poetry run ruff check .
+poetry run mypy src/
+```
+
+### Test Structure
+- **Unit Tests**: `tests/unit/` - Test individual components
+- **Integration Tests**: `tests/integration/` - Test component interactions
+- **E2E Tests**: `tests/e2e/` - Test complete workflows
+
+### Quality Gates
+- ✅ All tests pass
+- ✅ 90%+ test coverage
+- ✅ No linting errors
+- ✅ Type checking passes
+- ✅ Documentation updated
+
+---
+
+## 6. Documentation <a name="documentation"></a>
+
+### Documentation Types
+1. **Code Documentation** - Docstrings and type hints
+2. **User Documentation** - Usage guides and examples
+3. **API Documentation** - Auto-generated API references
+4. **Rule Documentation** - Rule specifications and examples
+
+### Adding New Rules
+Create a markdown file in `docs/rules/` with:
+
+```markdown
+# Rule ID: aws.access-key-id
+
+## Description
+Detects AWS Access Key IDs in code
+
+## Patterns
+- `AKIA[0-9A-Z]{16}`
+
+## Examples
+
+### Positive
+```python
+# This will trigger a finding
+aws_key = "AKIAIOSFODNN7EXAMPLE"
+```
+
+### Negative
+```python
+# This won't trigger (whitelisted)
+aws_key = "AKIAEXAMPLEEXAMPLE"
+```
+
+## Severity
+High
+
+## Tags
+aws, credentials, secrets
+```
+
+---
+
+## 7. Reporting Bugs <a name="reporting-bugs"></a>
+
+### Bug Report Template
+```markdown
+## Description
+Clear and concise description of the bug.
+
+## Steps to Reproduce
+1. Run command '...'
+2. Scan file '...'
+3. See error
+
+## Expected Behavior
+What you expected to happen.
+
+## Actual Behavior
+What actually happened.
+
+## Environment
+- Valkyrie Version: [e.g., 0.1.0]
+- Python Version: [e.g., 3.10.8]
+- OS: [e.g., Ubuntu 22.04]
+
+## Additional Context
+Logs, screenshots, or any other relevant information.
+```
+
+---
+
+## 8. Feature Proposals <a name="feature-proposals"></a>
+
+### Proposal Template
+```markdown
+## Problem Statement
+Describe the problem this feature solves.
+
+## Proposed Solution
+Describe your proposed solution.
+
+## Alternatives Considered
+Describe alternative solutions you've considered.
+
+## Use Cases
+Describe specific use cases this would enable.
+
+## Implementation Notes
+Any technical considerations or suggestions.
+```
+
+---
+
+## 9. Code of Conduct <a name="code-of-conduct"></a>
+
+### Our Pledge
+We are committed to providing a friendly, safe, and welcoming environment for all.
+
+### Our Standards
+- ✅ Use welcoming and inclusive language
+- ✅ Respect different viewpoints and experiences
+- ✅ Accept constructive criticism gracefully
+- ✅ Focus on what's best for the community
+
+### Unacceptable Behavior
+- ❌ Harassment of any kind
+- ❌ Trolling or insulting comments
+- ❌ Public or private harassment
+- ❌ Publishing others' private information
+
+### Enforcement
+Violations may result in temporary or permanent bans from the community.
+
+---
+
+## 🎯 Getting Help
+
+- **Discussions**: GitHub Discussions for questions
+- **Issues**: Bug reports and feature requests
+- **Discord**: Real-time chat (link in README)
+- **Documentation**: Check the docs/ folder first
+
+## 🏆 Your First Contribution
+
+1. Look for issues labeled `good first issue`
+2. Comment on the issue to express interest
+3. Follow the development workflow
+4. Ask for help if needed!
+
+Thank you for helping make Valkyrie better! 🚀
\ No newline at end of file

From 1afc3a09fe902c11053ab6fd75b238cbbd7c9865 Mon Sep 17 00:00:00 2001
From: Einswilli <wilfriedgoeh@gmail.com>
Date: Sat, 6 Sep 2025 17:56:11 +0000
Subject: [PATCH 04/17] Update CONTRUBUTING.md and Pyproject.toml files.

---
 .python-version |  2 +-
 CONTRIBUTING.md | 31 ++++++++++++++++---------------
 pyproject.toml  | 14 +++++++++-----
 3 files changed, 26 insertions(+), 21 deletions(-)

diff --git a/.python-version b/.python-version
index 24ee5b1..c8cfe39 100644
--- a/.python-version
+++ b/.python-version
@@ -1 +1 @@
-3.13
+3.10
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index bba36bf..0de2b20 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -20,7 +20,7 @@ Thank you for your interest in contributing to Valkyrie! This guide will help yo
 ### Prerequisites
 - Python 3.10+
 - Git
-- Poetry (for dependency management)
+- uv (for dependency management)
 
 ### Initial Setup
 ```bash
@@ -29,13 +29,13 @@ git clone https://github.com/AllDotPy/valkyrie.git
 cd valkyrie
 
 # Install dependencies
-poetry install
+uv sync
 
 # Install pre-commit hooks
-poetry run pre-commit install
+uv run pre-commit install
 
 # Verify installation
-poetry run valkyrie --version
+uv run valkyrie --version
 ```
 
 ### Development Environment
@@ -80,11 +80,11 @@ valkyrie/
 ## 3. Development Workflow <a name="development-workflow"></a>
 
 ### Branch Strategy
-- `main` - Stable production branch
+- `master` - Stable production branch
 - `develop` - Integration branch for features
-- `feature/*` - New features
-- `fix/*` - Bug fixes
-- `docs/*` - Documentation improvements
+- `feature.*` - New features
+- `fix.*` - Bug fixes
+- `docs.*` - Documentation improvements
 
 ### Contribution Process
 1. **Find an Issue** - Look for `good first issue` or `help wanted` labels
@@ -170,17 +170,17 @@ from valkyrie.domain.rules import Rule
 ### Running Tests
 ```bash
 # Run all tests
-poetry run pytest
+uv run pytest
 
 # Run with coverage
-poetry run pytest --cov=valkyrie
+uv run pytest --cov=valkyrie
 
 # Run specific test
-poetry run pytest tests/domain/test_rules.py -v
+uv run pytest tests/domain/test_rules.py -v
 
 # Run linting
-poetry run ruff check .
-poetry run mypy src/
+uv run ruff check .
+uv run mypy src/
 ```
 
 ### Test Structure
@@ -216,6 +216,7 @@ Detects AWS Access Key IDs in code
 
 ## Patterns
 - `AKIA[0-9A-Z]{16}`
+```
 
 ## Examples
 
@@ -226,7 +227,7 @@ aws_key = "AKIAIOSFODNN7EXAMPLE"
 ```
 
 ### Negative
-```python
+```
 # This won't trigger (whitelisted)
 aws_key = "AKIAEXAMPLEEXAMPLE"
 ```
@@ -236,7 +237,7 @@ High
 
 ## Tags
 aws, credentials, secrets
-```
+
 
 ---
 
diff --git a/pyproject.toml b/pyproject.toml
index f0c833d..55b0187 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -6,7 +6,11 @@ readme = "README.md"
 license = {file = "LICENSE"}
 authors = [{ name = "AllDotPy", email = "hello@alldotpy.com" }]
 maintainers = [{ name = "#Einswilli", email = "einswilligoeh@email.com" }]
-requires-python = ">=3.13"
+requires-python = ">=3.10"
+keywords = [
+    "valkyrie", "CI/CD", "security scaner", "guardian",
+    "pipelines"
+]
 dependencies = []
 
 [project.optional-dependencies]
@@ -24,10 +28,10 @@ dev = [
 ]
 
 [project.urls]
-Homepage = "https://alldotpy.github.io/FletX"
-Repository = "https://github.com/AllDotPy/FletX"
-Documentation = "https://alldotpy.github.io/FletX"
-Tracker = "https://github.com/AllDotPy/FletX/issues"
+# Homepage = "https://alldotpy.github.io/FletX"
+Repository = "https://github.com/AllDotPy/valkyrie"
+# Documentation = "https://alldotpy.github.io/FletX"
+Tracker = "https://github.com/AllDotPy/valkyrie/issues"
 
 [tool.setuptools]
 packages = ["valkyrie"]

From 30d578c20da5ee3b9a5e10162d6e49fe34fb441d Mon Sep 17 00:00:00 2001
From: Einswilli <wilfriedgoeh@gmail.com>
Date: Sat, 6 Sep 2025 17:58:21 +0000
Subject: [PATCH 05/17] Update CONTRUBUTING.md and Pyproject.toml files.

---
 CONTRIBUTING.md | 2 +-
 pyproject.toml  | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 0de2b20..68c4235 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -25,7 +25,7 @@ Thank you for your interest in contributing to Valkyrie! This guide will help yo
 ### Initial Setup
 ```bash
 # Fork the repository
-git clone https://github.com/AllDotPy/valkyrie.git
+git clone https://github.com/AllDotPy/Valkyrie.git
 cd valkyrie
 
 # Install dependencies
diff --git a/pyproject.toml b/pyproject.toml
index 55b0187..29822f4 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -29,9 +29,9 @@ dev = [
 
 [project.urls]
 # Homepage = "https://alldotpy.github.io/FletX"
-Repository = "https://github.com/AllDotPy/valkyrie"
+Repository = "https://github.com/AllDotPy/Valkyrie"
 # Documentation = "https://alldotpy.github.io/FletX"
-Tracker = "https://github.com/AllDotPy/valkyrie/issues"
+Tracker = "https://github.com/AllDotPy/Valkyrie/issues"
 
 [tool.setuptools]
 packages = ["valkyrie"]

From f1b4428fe5547ca309ffa609d853a32daa2ad415 Mon Sep 17 00:00:00 2001
From: Einswilli <wilfriedgoeh@gmail.com>
Date: Sat, 6 Sep 2025 18:00:17 +0000
Subject: [PATCH 06/17] remove main.py file form the root dir.

---
 main.py | 6 ------
 1 file changed, 6 deletions(-)
 delete mode 100644 main.py

diff --git a/main.py b/main.py
deleted file mode 100644
index addd523..0000000
--- a/main.py
+++ /dev/null
@@ -1,6 +0,0 @@
-def main():
-    print("Hello from valkyrie!")
-
-
-if __name__ == "__main__":
-    main()

From d6e780054374740906da40ee33f7760bfc9d800c Mon Sep 17 00:00:00 2001
From: Einswilli <wilfriedgoeh@gmail.com>
Date: Sat, 6 Sep 2025 20:11:35 +0000
Subject: [PATCH 07/17] valkyrie.core: Add Scanner engine and types modules.

---
 .gitignore               |   2 +-
 valkyrie/core/scanner.py | 214 ++++++++++++++++++++++++++++++
 valkyrie/core/types.py   | 279 +++++++++++++++++++++++++++++++++++++++
 3 files changed, 494 insertions(+), 1 deletion(-)
 create mode 100644 valkyrie/core/scanner.py
 create mode 100644 valkyrie/core/types.py

diff --git a/.gitignore b/.gitignore
index ae29df6..c85fc4a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -211,4 +211,4 @@ __marimo__/
 docs/*
 rules/*
 tests/*
-valkyrie/*
+# valkyrie/*
diff --git a/valkyrie/core/scanner.py b/valkyrie/core/scanner.py
new file mode 100644
index 0000000..c815c2f
--- /dev/null
+++ b/valkyrie/core/scanner.py
@@ -0,0 +1,214 @@
+"""
+Valkyrie Security Scanner - Core Architecture
+"""
+
+from pathlib import Path
+from typing import Dict, List, Optional
+import asyncio
+import logging
+from datetime import datetime
+
+
+from valkyrie.core.types import (
+    RuleRepository, ScannerPlugin, ScanRule,
+    ScanConfig, SecurityFinding, ScanResult,
+    ScanStatus
+)
+
+
+####
+##      VALKYRIE SCANNER ENGINE
+#####
+class ValkyrieScanner:
+    """
+    Main scanner engine that orchestrates security scanning
+    """
+    
+    def __init__(
+        self,
+        rule_repository: RuleRepository,
+        logger: Optional[logging.Logger] = None
+    ):
+        self.rule_repository = rule_repository
+        self.logger = logger or logging.getLogger(__name__)
+        self.plugins: Dict[str, ScannerPlugin] = {}
+        self._rules_cache: Optional[List[ScanRule]] = None
+    
+    async def register_plugin(self, plugin: ScannerPlugin) -> None:
+        """Register a scanner plugin"""
+
+        # Initialize the plugin
+        await plugin.initialize({})
+
+        # Then add it to the scanner registry
+        self.plugins[plugin.name] = plugin
+        self._rules_cache = None  # Invalidate cache
+        self.logger.info(f"Registered plugin: {plugin.name} v{plugin.version}")
+    
+    async def unregister_plugin(self, plugin_name: str) -> None:
+        """Unregister a scanner plugin"""
+
+        if plugin_name in self.plugins:
+            # Then perform cleanup before deleting it
+            await self.plugins[plugin_name].cleanup()
+
+            del self.plugins[plugin_name]
+            self._rules_cache = None  # Invalidate cache
+            self.logger.info(f"Unregistered plugin: {plugin_name}")
+    
+    async def _load_all_rules(self) -> List[ScanRule]:
+        """Load rules from repository and plugins"""
+        
+        if self._rules_cache is not None:
+            return self._rules_cache
+        
+        # Load from repository
+        rules = await self.rule_repository.load_rules()
+        
+        # Load from plugins
+        for plugin in self.plugins.values():
+            plugin_rules = await plugin.get_rules()
+            rules.extend(plugin_rules)
+        
+        self._rules_cache = rules
+        return rules
+    
+    def _get_scannable_files(self, config: ScanConfig) -> List[Path]:
+        """Get list of files to scan based on configuration"""
+
+        files = []
+        
+        for pattern in config.include_patterns:
+            for file_path in config.target_path.glob(pattern):
+                if not file_path.is_file():
+                    continue
+                
+                # Check file size
+                if file_path.stat().st_size > config.max_file_size:
+                    self.logger.warning(f"Skipping large file: {file_path}")
+                    continue
+                
+                # Check exclude patterns
+                should_exclude = any(
+                    file_path.match(exclude_pattern) 
+                    for exclude_pattern in config.exclude_patterns
+                )
+                
+                if not should_exclude:
+                    files.append(file_path)
+        
+        return files
+    
+    async def _scan_file(
+        self,
+        file_path: Path,
+        rules: List[ScanRule],
+        config: ScanConfig
+    ) -> List[SecurityFinding]:
+        """Scan a single file with applicable rules"""
+        findings = []
+        
+        try:
+            # Read file content
+            content = file_path.read_text(encoding='utf-8', errors='ignore')
+            
+            # Apply applicable rules
+            for rule in rules:
+                # Ignore disabled rules
+                if not rule.metadata.enabled:
+                    continue
+                
+                # Rule is not in rule filters
+                if config.rule_filters and rule.metadata.id not in config.rule_filters:
+                    continue
+                
+                # Rule does'nt have the least severity
+                if rule.metadata.severity.value < config.severity_threshold.value:
+                    continue
+                
+                if rule.is_applicable(file_path):
+                    try:
+                        rule_findings = await rule.scan(file_path, content)
+                        findings.extend(rule_findings)
+                    except Exception as e:
+                        self.logger.error(f"Rule {rule.metadata.id} failed on {file_path}: {e}")
+        
+        except Exception as e:
+            self.logger.error(f"Failed to scan file {file_path}: {e}")
+        
+        return findings
+    
+    async def scan(self, config: ScanConfig) -> ScanResult:
+        """
+        Execute security scan based on configuration
+        
+        Args:
+            config: Scan configuration
+            
+        Returns:
+            Complete scan results
+        """
+        
+        scan_id = f"scan_{datetime.now().isoformat()}"
+        start_time = datetime.now()
+        
+        self.logger.info(f"Starting security scan: {scan_id}")
+        
+        try:
+            # Load all rules
+            rules = await self._load_all_rules()
+            self.logger.info(f"Loaded {len(rules)} security rules")
+            
+            # Get files to scan
+            files_to_scan = self._get_scannable_files(config)
+            self.logger.info(f"Scanning {len(files_to_scan)} files")
+            
+            # Create scan tasks
+            semaphore = asyncio.Semaphore(config.parallel_workers)
+            
+            async def scan_with_semaphore(file_path: Path) -> List[SecurityFinding]:
+                async with semaphore:
+                    return await self._scan_file(file_path, rules, config)
+            
+            # Execute scans concurrently
+            scan_tasks = [scan_with_semaphore(file_path) for file_path in files_to_scan]
+            results = await asyncio.gather(*scan_tasks, return_exceptions=True)
+            
+            # Collect findings and errors
+            all_findings = []
+            errors = []
+            
+            for result in results:
+                if isinstance(result, Exception):
+                    errors.append(str(result))
+                else:
+                    all_findings.extend(result)
+            
+            # Calculate duration
+            scan_duration = (datetime.now() - start_time).total_seconds()
+            
+            scan_result = ScanResult(
+                scan_id=scan_id,
+                status=ScanStatus.COMPLETED,
+                findings=all_findings,
+                scan_duration=scan_duration,
+                scanned_files=set(files_to_scan),
+                errors=errors
+            )
+            
+            self.logger.info(
+                f"Scan completed: {len(all_findings)} findings, "
+                f"{scan_result.critical_count} critical, "
+                f"{scan_result.high_count} high severity"
+            )
+            
+            return scan_result
+            
+        except Exception as e:
+            self.logger.error(f"Scan failed: {e}")
+            return ScanResult(
+                scan_id=scan_id,
+                status=ScanStatus.FAILED,
+                errors=[str(e)],
+                scan_duration=(datetime.now() - start_time).total_seconds()
+            )
diff --git a/valkyrie/core/types.py b/valkyrie/core/types.py
new file mode 100644
index 0000000..851b138
--- /dev/null
+++ b/valkyrie/core/types.py
@@ -0,0 +1,279 @@
+from abc import ABC, abstractmethod
+from dataclasses import dataclass, field
+from enum import Enum
+from pathlib import Path
+from typing import Dict, List, Optional, Set, Any, Protocol
+from datetime import datetime
+
+
+####
+##      SECURITY LEVEL ENUM
+#####
+class SeverityLevel(Enum):
+    """Security finding severity levels"""
+
+    CRITICAL = "critical"
+    HIGH = "high" 
+    MEDIUM = "medium"
+    LOW = "low"
+    INFO = "info"
+
+
+####
+##      SECURITY FINDING CATEGORIES ENUM
+#####
+class FindingCategory(Enum):
+    """Categories of security findings"""
+
+    SECRETS = "secrets"
+    DEPENDENCIES = "dependencies"
+    IAM_CONFIG = "iam_config"
+    CODE_QUALITY = "code_quality"
+    INFRASTRUCTURE = "infrastructure"
+    CUSTOM = "custom"
+
+
+####
+##      SECURITY SCAN STATUS ENUM
+#####
+class ScanStatus(Enum):
+    """Status of scan execution"""
+
+    PENDING = "pending"
+    RUNNING = "running"
+    COMPLETED = "completed"
+    FAILED = "failed"
+    CANCELLED = "cancelled"
+
+
+#### DATA MODELS
+
+####
+##      FILE LOCATION REPRESENTATION MODEL
+#####
+@dataclass(frozen=True)
+class FileLocation:
+    """Represents a location within a file"""
+
+    file_path: Path
+    line_number: int
+    column_start: int = 0
+    column_end: int = 0
+    
+    def __str__(self) -> str:
+        return f"{self.file_path}:{self.line_number}"
+
+
+####
+##      SECURITY SCAN ISSUE
+#####
+@dataclass(frozen=True)
+class SecurityFinding:
+    """Represents a security issue found during scanning"""
+
+    id: str
+    title: str
+    description: str
+    severity: SeverityLevel
+    category: FindingCategory
+    location: FileLocation
+    rule_id: str
+    confidence: float = 1.0  # 0.0 to 1.0
+    metadata: Dict[str, Any] = field(default_factory=dict)
+    remediation_advice: Optional[str] = None
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Convert finding to dictionary for serialization"""
+
+        return {
+            "id": self.id,
+            "title": self.title,
+            "description": self.description,
+            "severity": self.severity.value,
+            "category": self.category.value,
+            "location": {
+                "file_path": str(self.location.file_path),
+                "line_number": self.location.line_number,
+                "column_start": self.location.column_start,
+                "column_end": self.location.column_end,
+            },
+            "rule_id": self.rule_id,
+            "confidence": self.confidence,
+            "metadata": self.metadata,
+            "remediation_advice": self.remediation_advice,
+        }
+
+
+####
+##      SECURITY SCAN RESULT
+#####
+@dataclass
+class ScanResult:
+    """Complete result of a security scan"""
+
+    scan_id: str
+    status: ScanStatus
+    findings: List[SecurityFinding] = field(default_factory=list)
+    scan_duration: Optional[float] = None
+    timestamp: datetime = field(default_factory=datetime.now)
+    scanned_files: Set[Path] = field(default_factory=set)
+    errors: List[str] = field(default_factory=list)
+    
+    @property
+    def critical_count(self) -> int:
+        return sum(1 for f in self.findings if f.severity == SeverityLevel.CRITICAL)
+    
+    @property
+    def high_count(self) -> int:
+        return sum(1 for f in self.findings if f.severity == SeverityLevel.HIGH)
+    
+    @property
+    def has_blocking_issues(self) -> bool:
+        """Check if scan has critical or high severity issues"""
+        return self.critical_count > 0 or self.high_count > 0
+
+
+####
+##      RULE METADATA MODEL
+#####
+@dataclass(frozen=True)
+class RuleMetadata:
+    """Metadata for a security rule"""
+
+    id: str
+    name: str
+    description: str
+    category: FindingCategory
+    severity: SeverityLevel
+    author: str
+    version: str = "1.0.0"
+    tags: Set[str] = field(default_factory=set)
+    enabled: bool = True
+
+
+####
+##      SECURITY SCAN RULE PROTOCOL
+#####
+class ScanRule(Protocol):
+    """Protocol defining the interface for security rules"""
+    
+    @property
+    def metadata(self) -> RuleMetadata:
+        """Rule metadata"""
+        ...
+    
+    async def scan(self, file_path: Path, content: str) -> List[SecurityFinding]:
+        """
+        Scan file content and return security findings
+        
+        Args:
+            file_path: Path to the file being scanned
+            content: File content as string
+            
+        Returns:
+            List of security findings
+        """
+        ...
+    
+    def is_applicable(self, file_path: Path) -> bool:
+        """
+        Check if this rule should be applied to the given file
+        
+        Args:
+            file_path: Path to check
+            
+        Returns:
+            True if rule is applicable, False otherwise
+        """
+        ...
+
+
+####    PLUGIN SYSTEM 
+
+####
+##     SCANNER PLUGINS BASE CLASS
+#####
+class ScannerPlugin(ABC):
+    """Abstract base class for scanner plugins"""
+    
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Plugin name"""
+        pass
+    
+    @property
+    @abstractmethod
+    def version(self) -> str:
+        """Plugin version"""
+        pass
+    
+    @abstractmethod
+    async def initialize(self, config: Dict[str, Any]) -> None:
+        """Initialize the plugin with configuration"""
+        pass
+    
+    @abstractmethod
+    async def get_rules(self) -> List[ScanRule]:
+        """Return list of rules provided by this plugin"""
+        pass
+    
+    @abstractmethod
+    async def cleanup(self) -> None:
+        """Cleanup plugin resources"""
+        pass
+
+
+####    RULE REPOSITORY
+
+####
+##      SECURITY SCAN RULE REPOSITORY
+#####
+class RuleRepository(ABC):
+    """Abstract interface for rule storage and retrieval"""
+    
+    @abstractmethod
+    async def load_rules(self) -> List[ScanRule]:
+        """Load all available rules"""
+        pass
+    
+    @abstractmethod
+    async def get_rule(self, rule_id: str) -> Optional[ScanRule]:
+        """Get specific rule by ID"""
+        pass
+    
+    @abstractmethod
+    async def add_rule(self, rule: ScanRule) -> None:
+        """Add a new rule"""
+        pass
+    
+    @abstractmethod
+    async def update_rule(self, rule: ScanRule) -> None:
+        """Update existing rule"""
+        pass
+
+
+####    CONFIG
+
+####
+##      SCANNER CONFIG MODEL CLASS
+#####
+@dataclass
+class ScanConfig:
+    """Configuration for scanner execution"""
+
+    target_path: Path
+    include_patterns: List[str] = field(
+        default_factory=lambda: ["**/*"]
+    )
+    exclude_patterns: List[str] = field(
+        default_factory=lambda: [
+            "**/.git/**", "**/.vscode/**",
+            "**/node_modules/**", "**/__pycache__/**"
+        ]
+    )
+    max_file_size: int = 10 * 1024 * 1024  # 10MB
+    parallel_workers: int = 4
+    rule_filters: Set[str] = field(default_factory=set)  # Rule IDs to include
+    severity_threshold: SeverityLevel = SeverityLevel.LOW
+    fail_on_findings: bool = True
\ No newline at end of file

From 6c125cffb654a27b509454d10d10d65a52c4cc44 Mon Sep 17 00:00:00 2001
From: Einswilli <wilfriedgoeh@gmail.com>
Date: Sun, 7 Sep 2025 16:28:38 +0000
Subject: [PATCH 08/17] valkyrie.plugins: Add Security Rules Base class Secrets
 detector Plugin.

---
 valkyrie/plugins/__init__.py |  30 +++++
 valkyrie/plugins/secrets.py  | 222 +++++++++++++++++++++++++++++++++++
 2 files changed, 252 insertions(+)
 create mode 100644 valkyrie/plugins/__init__.py
 create mode 100644 valkyrie/plugins/secrets.py

diff --git a/valkyrie/plugins/__init__.py b/valkyrie/plugins/__init__.py
new file mode 100644
index 0000000..99b293e
--- /dev/null
+++ b/valkyrie/plugins/__init__.py
@@ -0,0 +1,30 @@
+"""
+"""
+from pathlib import Path
+from typing import List
+
+from valkyrie.core.types import (
+    RuleMetadata, SecurityFinding, ScanRule
+)
+
+
+####
+##      BASE CLASS FOR SECURITY RULE IMPLEMENTATION
+#####
+class BaseSecurityRule(ScanRule):
+    """Base implementation for security rules"""
+    
+    def __init__(self, metadata: RuleMetadata):
+        self._metadata = metadata
+    
+    @property
+    def metadata(self) -> RuleMetadata:
+        return self._metadata
+    
+    def is_applicable(self, file_path: Path) -> bool:
+        """Default implementation - override in subclasses"""
+        return True
+    
+    async def scan(self, file_path: Path, content: str) -> List[SecurityFinding]:
+        """Override in subclasses"""
+        return []
diff --git a/valkyrie/plugins/secrets.py b/valkyrie/plugins/secrets.py
new file mode 100644
index 0000000..558cbc9
--- /dev/null
+++ b/valkyrie/plugins/secrets.py
@@ -0,0 +1,222 @@
+"""
+"""
+import re
+import hashlib
+from typing import (
+    Set, List, Pattern, Dict, Any
+)
+from pathlib import Path
+from dataclasses import dataclass, field
+
+from valkyrie.plugins import BaseSecurityRule
+from valkyrie.core.types import (
+    RuleMetadata, FindingCategory, SeverityLevel,
+    SecurityFinding, ScanRule, ScannerPlugin,
+    FileLocation
+)
+
+
+####
+##      SECRET PATTERN MODEL
+#####
+@dataclass
+class SecretPattern:
+    """Pattern definition for secret detection"""
+
+    name: str
+    pattern: Pattern[str]
+    entropy_threshold: float = 0.0
+    keywords: Set[str] = field(default_factory=set)
+    file_extensions: Set[str] = field(default_factory=set)
+
+
+####
+##      SECRET DETECTION RULE
+#####
+class SecretsDetectionRule(BaseSecurityRule):
+    """Rule for detecting secrets and credentials"""
+    
+    def __init__(self):
+        metadata = RuleMetadata(
+            id = "secrets-001",
+            name = "Generic Secrets Detection",
+            description = "Detects API keys, tokens, passwords, and other secrets",
+            category = FindingCategory.SECRETS,
+            severity = SeverityLevel.CRITICAL,
+            author = "Valkyrie Core Team",
+            tags = {"secrets", "credentials", "api-keys"}
+        )
+        super().__init__(metadata)
+        
+        # Define secret patterns
+        self.patterns = [
+            SecretPattern(
+                name = "AWS Access Key",
+                pattern = re.compile(r'AKIA[0-9A-Z]{16}', re.IGNORECASE),
+                keywords = {"aws", "amazon", "access", "key"}
+            ),
+            SecretPattern(
+                name = "Generic API Key",
+                pattern = re.compile(r'(?i)(api[_-]?key|apikey|secret[_-]?key|secretkey)\s*[:=]\s*["\']?([a-z0-9]{20,})', re.IGNORECASE),
+                entropy_threshold = 3.5
+            ),
+            SecretPattern(
+                name = "JWT Token",
+                pattern = re.compile(r'eyJ[a-zA-Z0-9_-]*\.eyJ[a-zA-Z0-9_-]*\.[a-zA-Z0-9_-]*'),
+                keywords = {"jwt", "token", "bearer"}
+            ),
+            SecretPattern(
+                name = "GitHub Token",
+                pattern = re.compile(r'gh[pousr]_[A-Za-z0-9_]{36}'),
+                keywords = {"github", "token"}
+            ),
+            SecretPattern(
+                name = "Private Key",
+                pattern = re.compile(r'-----BEGIN [A-Z ]+ PRIVATE KEY-----'),
+                keywords = {"private", "key", "rsa", "ssh"}
+            ),
+            SecretPattern(
+                name = "Database Connection String",
+                pattern = re.compile(r'(mongodb|mysql|postgres|redis)://[^\s]+', re.IGNORECASE),
+                keywords = {"database", "connection", "string"}
+            )
+        ]
+    
+    def _calculate_entropy(self, text: str) -> float:
+        """Calculate Shannon entropy of text"""
+
+        if not text:
+            return 0
+        
+        # Get character frequencies
+        frequencies = {}
+        for char in text:
+            frequencies[char] = frequencies.get(char, 0) + 1
+        
+        # Calculate entropy
+        entropy = 0
+        length = len(text)
+        for freq in frequencies.values():
+            probability = freq / length
+            entropy -= probability * (probability.bit_length() - 1)
+        
+        return entropy
+    
+    def is_applicable(self, file_path: Path) -> bool:
+        """Check if file should be scanned for secrets"""
+        # Skip binary files and common non-text files
+        skip_extensions = {
+            '.jpg', '.jpeg', '.png', '.gif', 
+            '.pdf', '.zip', '.tar', '.gz', 
+            '.exe', '.dll', '.so', '.dmg'
+        }
+        if file_path.suffix.lower() in skip_extensions:
+            return False
+        
+        return True
+    
+    async def scan(self, file_path: Path, content: str) -> List[SecurityFinding]:
+        """Scan for secrets in file content"""
+
+        findings = []
+        lines = content.split('\n')
+        
+        for line_num, line in enumerate(lines, 1):
+            # Skip comments and obvious false positives
+            line_lower = line.lower().strip()
+            if (line_lower.startswith('#') or 
+                line_lower.startswith('//') or 
+                'example' in line_lower or 
+                'placeholder' in line_lower or 
+                'your_api_key_here' in line_lower):
+                continue
+            
+            for pattern in self.patterns:
+                matches = pattern.pattern.finditer(line)
+                
+                for match in matches:
+                    matched_text = match.group()
+                    
+                    # Check entropy if threshold is set
+                    if pattern.entropy_threshold > 0:
+                        entropy = self._calculate_entropy(matched_text)
+                        if entropy < pattern.entropy_threshold:
+                            continue
+                    
+                    # Calculate confidence based on context
+                    confidence = self._calculate_confidence(line, pattern)
+                    
+                    finding = SecurityFinding(
+                        id = hashlib.md5(f"{file_path}:{line_num}:{matched_text}".encode()).hexdigest(),
+                        title = f"Potential {pattern.name} detected",
+                        description = f"Found pattern matching {pattern.name} in {file_path}",
+                        severity = self.metadata.severity,
+                        category = self.metadata.category,
+                        location =FileLocation(
+                            file_path = file_path,
+                            line_number = line_num,
+                            column_start = match.start(),
+                            column_end = match.end()
+                        ),
+                        rule_id = self.metadata.id,
+                        confidence = confidence,
+                        metadata = {
+                            "pattern_name": pattern.name,
+                            "matched_text": matched_text[:50] + "..." if len(matched_text) > 50 else matched_text,
+                            "line_content": line.strip()
+                        },
+                        remediation_advice = (
+                            f"Remove or secure the {pattern.name}. "
+                            "Consider using environment variables or secure vault services."
+                        )
+                    )
+                    findings.append(finding)
+        
+        return findings
+    
+    def _calculate_confidence(self, line: str, pattern: SecretPattern) -> float:
+        """Calculate confidence score for a potential secret"""
+
+        confidence = 0.5  # Base confidence
+        
+        # Increase confidence if keywords are present
+        line_lower = line.lower()
+        for keyword in pattern.keywords:
+            if keyword in line_lower:
+                confidence += 0.1
+        
+        # Decrease confidence for test files
+        if any(
+            test_indicator in line_lower 
+            for test_indicator in ['test', 'example', 'demo', 'fake']
+        ):
+            confidence -= 0.3
+        
+        return max(0.0, min(1.0, confidence))
+
+
+####
+##      SECRETS PLUGIN
+#####
+class SecretsPlugin(ScannerPlugin):
+    """Plugin for secrets detection"""
+    
+    @property
+    def name(self) -> str:
+        return "secrets-detector"
+    
+    @property
+    def version(self) -> str:
+        return "1.0.0"
+    
+    async def initialize(self, config: Dict[str, Any]) -> None:
+        """Initialize secrets plugin"""
+        pass
+    
+    async def get_rules(self) -> List[ScanRule]:
+        """Return secrets detection rules"""
+        return [SecretsDetectionRule()]
+    
+    async def cleanup(self) -> None:
+        """Cleanup plugin resources"""
+        pass
\ No newline at end of file

From 1ba03528a2f9398730a70d575f979397d2af8169 Mon Sep 17 00:00:00 2001
From: Einswilli <wilfriedgoeh@gmail.com>
Date: Sun, 7 Sep 2025 16:59:51 +0000
Subject: [PATCH 09/17] valkyrie.plugins: Add Plugin manager.

---
 valkyrie/plugins/secrets.py | 62 ++++++++++++++++++++++++++++++++++++-
 1 file changed, 61 insertions(+), 1 deletion(-)

diff --git a/valkyrie/plugins/secrets.py b/valkyrie/plugins/secrets.py
index 558cbc9..5f47810 100644
--- a/valkyrie/plugins/secrets.py
+++ b/valkyrie/plugins/secrets.py
@@ -219,4 +219,64 @@ async def get_rules(self) -> List[ScanRule]:
     
     async def cleanup(self) -> None:
         """Cleanup plugin resources"""
-        pass
\ No newline at end of file
+        pass
+
+
+####
+##      PLUGUN MANAGER CLASS
+#####
+class PluginManager:
+    """Manages scanner plugins and their lifecycle"""
+    
+    def __init__(self):
+        self.plugins: Dict[str, ScannerPlugin] = {}
+        self.enabled_plugins: Set[str] = set()
+    
+    async def register_plugin(
+        self, 
+        plugin: ScannerPlugin, 
+        config: Dict[str, Any] = None
+    ) -> None:
+        """Register and initialize a plugin"""
+        
+        await plugin.initialize(config or {})
+        self.plugins[plugin.name] = plugin
+        self.enabled_plugins.add(plugin.name)
+    
+    async def unregister_plugin(self, plugin_name: str) -> None:
+        """Unregister a plugin"""
+
+        if plugin_name in self.plugins:
+            await self.plugins[plugin_name].cleanup()
+            del self.plugins[plugin_name]
+            self.enabled_plugins.discard(plugin_name)
+    
+    def enable_plugin(self, plugin_name: str) -> None:
+        """Enable a registered plugin"""
+
+        if plugin_name in self.plugins:
+            self.enabled_plugins.add(plugin_name)
+    
+    def disable_plugin(self, plugin_name: str) -> None:
+        """Disable a plugin"""
+        self.enabled_plugins.discard(plugin_name)
+    
+    async def get_all_rules(self) -> List[ScanRule]:
+        """Get rules from all enabled plugins"""
+        
+        all_rules = []
+        
+        for plugin_name in self.enabled_plugins:
+            if plugin_name in self.plugins:
+                plugin_rules = await self.plugins[plugin_name].get_rules()
+                all_rules.extend(plugin_rules)
+        
+        return all_rules
+    
+    async def cleanup_all(self) -> None:
+        """Cleanup all plugins"""
+        for plugin in self.plugins.values():
+            await plugin.cleanup()
+        
+        self.plugins.clear()
+        self.enabled_plugins.clear()

From d0233433d29e36585fb9089e7fbd4cfdcd46b7af Mon Sep 17 00:00:00 2001
From: Einswilli <wilfriedgoeh@gmail.com>
Date: Sun, 7 Sep 2025 17:25:39 +0000
Subject: [PATCH 10/17] valkyrie.plugins: Add Plugin manager.

---
 valkyrie/plugins/__init__.py | 67 ++++++++++++++++++++++++++++++++++--
 valkyrie/plugins/secrets.py  | 60 --------------------------------
 2 files changed, 65 insertions(+), 62 deletions(-)

diff --git a/valkyrie/plugins/__init__.py b/valkyrie/plugins/__init__.py
index 99b293e..c087a47 100644
--- a/valkyrie/plugins/__init__.py
+++ b/valkyrie/plugins/__init__.py
@@ -1,10 +1,11 @@
 """
 """
 from pathlib import Path
-from typing import List
+from typing import List, Set, Dict, Any
 
 from valkyrie.core.types import (
-    RuleMetadata, SecurityFinding, ScanRule
+    RuleMetadata, SecurityFinding, ScanRule,
+    ScannerPlugin
 )
 
 
@@ -28,3 +29,65 @@ def is_applicable(self, file_path: Path) -> bool:
     async def scan(self, file_path: Path, content: str) -> List[SecurityFinding]:
         """Override in subclasses"""
         return []
+
+
+
+
+####
+##      PLUGUN MANAGER CLASS
+#####
+class PluginManager:
+    """Manages scanner plugins and their lifecycle"""
+    
+    def __init__(self):
+        self.plugins: Dict[str, ScannerPlugin] = {}
+        self.enabled_plugins: Set[str] = set()
+    
+    async def register_plugin(
+        self, 
+        plugin: ScannerPlugin, 
+        config: Dict[str, Any] = None
+    ) -> None:
+        """Register and initialize a plugin"""
+        
+        await plugin.initialize(config or {})
+        self.plugins[plugin.name] = plugin
+        self.enabled_plugins.add(plugin.name)
+    
+    async def unregister_plugin(self, plugin_name: str) -> None:
+        """Unregister a plugin"""
+
+        if plugin_name in self.plugins:
+            await self.plugins[plugin_name].cleanup()
+            del self.plugins[plugin_name]
+            self.enabled_plugins.discard(plugin_name)
+    
+    def enable_plugin(self, plugin_name: str) -> None:
+        """Enable a registered plugin"""
+
+        if plugin_name in self.plugins:
+            self.enabled_plugins.add(plugin_name)
+    
+    def disable_plugin(self, plugin_name: str) -> None:
+        """Disable a plugin"""
+        self.enabled_plugins.discard(plugin_name)
+    
+    async def get_all_rules(self) -> List[ScanRule]:
+        """Get rules from all enabled plugins"""
+        
+        all_rules = []
+        
+        for plugin_name in self.enabled_plugins:
+            if plugin_name in self.plugins:
+                plugin_rules = await self.plugins[plugin_name].get_rules()
+                all_rules.extend(plugin_rules)
+        
+        return all_rules
+    
+    async def cleanup_all(self) -> None:
+        """Cleanup all plugins"""
+        for plugin in self.plugins.values():
+            await plugin.cleanup()
+        
+        self.plugins.clear()
+        self.enabled_plugins.clear()
diff --git a/valkyrie/plugins/secrets.py b/valkyrie/plugins/secrets.py
index 5f47810..600c93e 100644
--- a/valkyrie/plugins/secrets.py
+++ b/valkyrie/plugins/secrets.py
@@ -220,63 +220,3 @@ async def get_rules(self) -> List[ScanRule]:
     async def cleanup(self) -> None:
         """Cleanup plugin resources"""
         pass
-
-
-####
-##      PLUGUN MANAGER CLASS
-#####
-class PluginManager:
-    """Manages scanner plugins and their lifecycle"""
-    
-    def __init__(self):
-        self.plugins: Dict[str, ScannerPlugin] = {}
-        self.enabled_plugins: Set[str] = set()
-    
-    async def register_plugin(
-        self, 
-        plugin: ScannerPlugin, 
-        config: Dict[str, Any] = None
-    ) -> None:
-        """Register and initialize a plugin"""
-        
-        await plugin.initialize(config or {})
-        self.plugins[plugin.name] = plugin
-        self.enabled_plugins.add(plugin.name)
-    
-    async def unregister_plugin(self, plugin_name: str) -> None:
-        """Unregister a plugin"""
-
-        if plugin_name in self.plugins:
-            await self.plugins[plugin_name].cleanup()
-            del self.plugins[plugin_name]
-            self.enabled_plugins.discard(plugin_name)
-    
-    def enable_plugin(self, plugin_name: str) -> None:
-        """Enable a registered plugin"""
-
-        if plugin_name in self.plugins:
-            self.enabled_plugins.add(plugin_name)
-    
-    def disable_plugin(self, plugin_name: str) -> None:
-        """Disable a plugin"""
-        self.enabled_plugins.discard(plugin_name)
-    
-    async def get_all_rules(self) -> List[ScanRule]:
-        """Get rules from all enabled plugins"""
-        
-        all_rules = []
-        
-        for plugin_name in self.enabled_plugins:
-            if plugin_name in self.plugins:
-                plugin_rules = await self.plugins[plugin_name].get_rules()
-                all_rules.extend(plugin_rules)
-        
-        return all_rules
-    
-    async def cleanup_all(self) -> None:
-        """Cleanup all plugins"""
-        for plugin in self.plugins.values():
-            await plugin.cleanup()
-        
-        self.plugins.clear()
-        self.enabled_plugins.clear()

From a2fef8b867ad151c919735493b2e55c4bfb596fe Mon Sep 17 00:00:00 2001
From: Einswilli <wilfriedgoeh@gmail.com>
Date: Sun, 7 Sep 2025 17:26:35 +0000
Subject: [PATCH 11/17] valkyrie.plugins: Add Plugin manager.

---
 valkyrie/plugins/__init__.py | 2 --
 1 file changed, 2 deletions(-)

diff --git a/valkyrie/plugins/__init__.py b/valkyrie/plugins/__init__.py
index c087a47..7c6eedb 100644
--- a/valkyrie/plugins/__init__.py
+++ b/valkyrie/plugins/__init__.py
@@ -31,8 +31,6 @@ async def scan(self, file_path: Path, content: str) -> List[SecurityFinding]:
         return []
 
 
-
-
 ####
 ##      PLUGUN MANAGER CLASS
 #####

From e1238c4acbce8833eef00652b99c2bd35c3e8835 Mon Sep 17 00:00:00 2001
From: Einswilli <wilfriedgoeh@gmail.com>
Date: Sun, 7 Sep 2025 17:35:15 +0000
Subject: [PATCH 12/17] valkyrie.plugins: Add Plugin manager.

---
 valkyrie/plugins/__init__.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/valkyrie/plugins/__init__.py b/valkyrie/plugins/__init__.py
index 7c6eedb..000287b 100644
--- a/valkyrie/plugins/__init__.py
+++ b/valkyrie/plugins/__init__.py
@@ -26,8 +26,13 @@ def is_applicable(self, file_path: Path) -> bool:
         """Default implementation - override in subclasses"""
         return True
     
-    async def scan(self, file_path: Path, content: str) -> List[SecurityFinding]:
+    async def scan(
+        self, 
+        file_path: Path, 
+        content: str
+    ) -> List[SecurityFinding]:
         """Override in subclasses"""
+        
         return []
 
 

From f0310b47a18d169f2ed11b0743dc66f128e6726e Mon Sep 17 00:00:00 2001
From: Einswilli <wilfriedgoeh@gmail.com>
Date: Mon, 8 Sep 2025 07:25:40 +0000
Subject: [PATCH 13/17] refractor: valkyrie.plugins.secrets.

---
 .../{secrets.py => secrets/__init__.py}       | 53 ++----------------
 valkyrie/plugins/secrets/conf.py              | 54 +++++++++++++++++++
 2 files changed, 59 insertions(+), 48 deletions(-)
 rename valkyrie/plugins/{secrets.py => secrets/__init__.py} (76%)
 create mode 100644 valkyrie/plugins/secrets/conf.py

diff --git a/valkyrie/plugins/secrets.py b/valkyrie/plugins/secrets/__init__.py
similarity index 76%
rename from valkyrie/plugins/secrets.py
rename to valkyrie/plugins/secrets/__init__.py
index fe7f7b6..0fd003f 100644
--- a/valkyrie/plugins/secrets.py
+++ b/valkyrie/plugins/secrets/__init__.py
@@ -1,13 +1,11 @@
 """
 Valkyrie Secretis Detector Plugin.
 """
-import re
 import hashlib
 from typing import (
-    Set, List, Pattern, Dict, Any
+    List, Dict, Any
 )
 from pathlib import Path
-from dataclasses import dataclass, field
 
 from valkyrie.plugins import BaseSecurityRule
 from valkyrie.core.types import (
@@ -16,19 +14,9 @@
     FileLocation
 )
 
-
-####
-##      SECRET PATTERN MODEL
-#####
-@dataclass
-class SecretPattern:
-    """Pattern definition for secret detection"""
-
-    name: str
-    pattern: Pattern[str]
-    entropy_threshold: float = 0.0
-    keywords: Set[str] = field(default_factory=set)
-    file_extensions: Set[str] = field(default_factory=set)
+from valkyrie.plugins.secrets.conf import (
+    SECRETS_PATTERNS, SecretPattern
+)
 
 
 ####
@@ -50,38 +38,7 @@ def __init__(self):
         super().__init__(metadata)
         
         # Define secret patterns
-        self.patterns = [
-            SecretPattern(
-                name = "AWS Access Key",
-                pattern = re.compile(r'AKIA[0-9A-Z]{16}', re.IGNORECASE),
-                keywords = {"aws", "amazon", "access", "key"}
-            ),
-            SecretPattern(
-                name = "Generic API Key",
-                pattern = re.compile(r'(?i)(api[_-]?key|apikey|secret[_-]?key|secretkey)\s*[:=]\s*["\']?([a-z0-9]{20,})', re.IGNORECASE),
-                entropy_threshold = 3.5
-            ),
-            SecretPattern(
-                name = "JWT Token",
-                pattern = re.compile(r'eyJ[a-zA-Z0-9_-]*\.eyJ[a-zA-Z0-9_-]*\.[a-zA-Z0-9_-]*'),
-                keywords = {"jwt", "token", "bearer"}
-            ),
-            SecretPattern(
-                name = "GitHub Token",
-                pattern = re.compile(r'gh[pousr]_[A-Za-z0-9_]{36}'),
-                keywords = {"github", "token"}
-            ),
-            SecretPattern(
-                name = "Private Key",
-                pattern = re.compile(r'-----BEGIN [A-Z ]+ PRIVATE KEY-----'),
-                keywords = {"private", "key", "rsa", "ssh"}
-            ),
-            SecretPattern(
-                name = "Database Connection String",
-                pattern = re.compile(r'(mongodb|mysql|postgres|redis)://[^\s]+', re.IGNORECASE),
-                keywords = {"database", "connection", "string"}
-            )
-        ]
+        self.patterns = SECRETS_PATTERNS
     
     def _calculate_entropy(self, text: str) -> float:
         """Calculate Shannon entropy of text"""
diff --git a/valkyrie/plugins/secrets/conf.py b/valkyrie/plugins/secrets/conf.py
new file mode 100644
index 0000000..2cad3a3
--- /dev/null
+++ b/valkyrie/plugins/secrets/conf.py
@@ -0,0 +1,54 @@
+import re
+from dataclasses import dataclass, field
+from typing import (
+    Set, Pattern
+)
+
+
+####
+##      SECRET PATTERN MODEL
+#####
+@dataclass
+class SecretPattern:
+    """Pattern definition for secret detection"""
+
+    name: str
+    pattern: Pattern[str]
+    entropy_threshold: float = 0.0
+    keywords: Set[str] = field(default_factory=set)
+    file_extensions: Set[str] = field(default_factory=set)
+
+
+####    
+SECRETS_PATTERNS = [
+    SecretPattern(
+        name = "AWS Access Key",
+        pattern = re.compile(r'AKIA[0-9A-Z]{16}', re.IGNORECASE),
+        keywords = {"aws", "amazon", "access", "key"}
+    ),
+    SecretPattern(
+        name = "Generic API Key",
+        pattern = re.compile(r'(?i)(api[_-]?key|apikey|secret[_-]?key|secretkey)\s*[:=]\s*["\']?([a-z0-9]{20,})', re.IGNORECASE),
+        entropy_threshold = 3.5
+    ),
+    SecretPattern(
+        name = "JWT Token",
+        pattern = re.compile(r'eyJ[a-zA-Z0-9_-]*\.eyJ[a-zA-Z0-9_-]*\.[a-zA-Z0-9_-]*'),
+        keywords = {"jwt", "token", "bearer"}
+    ),
+    SecretPattern(
+        name = "GitHub Token",
+        pattern = re.compile(r'gh[pousr]_[A-Za-z0-9_]{36}'),
+        keywords = {"github", "token"}
+    ),
+    SecretPattern(
+        name = "Private Key",
+        pattern = re.compile(r'-----BEGIN [A-Z ]+ PRIVATE KEY-----'),
+        keywords = {"private", "key", "rsa", "ssh"}
+    ),
+    SecretPattern(
+        name = "Database Connection String",
+        pattern = re.compile(r'(mongodb|mysql|postgres|redis)://[^\s]+', re.IGNORECASE),
+        keywords = {"database", "connection", "string"}
+    )
+]
\ No newline at end of file

From f405674a426bb6d590a82d1c1a8b75216ae1c79d Mon Sep 17 00:00:00 2001
From: Einswilli <wilfriedgoeh@gmail.com>
Date: Thu, 11 Sep 2025 18:10:46 +0200
Subject: [PATCH 14/17] valkyrie,plugins: add vulnera vulnerablity scanner
 plugin

---
 valkyrie/plugins/__init__.py         |  16 +-
 valkyrie/plugins/vulnera/__init__.py | 172 +++++++
 valkyrie/plugins/vulnera/conf.py     |  60 +++
 valkyrie/plugins/vulnera/parser.py   | 652 +++++++++++++++++++++++++++
 4 files changed, 897 insertions(+), 3 deletions(-)
 create mode 100644 valkyrie/plugins/vulnera/__init__.py
 create mode 100644 valkyrie/plugins/vulnera/conf.py
 create mode 100644 valkyrie/plugins/vulnera/parser.py

diff --git a/valkyrie/plugins/__init__.py b/valkyrie/plugins/__init__.py
index 000287b..4818cd4 100644
--- a/valkyrie/plugins/__init__.py
+++ b/valkyrie/plugins/__init__.py
@@ -1,7 +1,8 @@
 """
 """
 from pathlib import Path
-from typing import List, Set, Dict, Any
+from typing import List, Set, Dict, Any, Optional
+import logging
 
 from valkyrie.core.types import (
     RuleMetadata, SecurityFinding, ScanRule,
@@ -15,8 +16,13 @@
 class BaseSecurityRule(ScanRule):
     """Base implementation for security rules"""
     
-    def __init__(self, metadata: RuleMetadata):
+    def __init__(
+        self, 
+        metadata: RuleMetadata,
+        logger: Optional[logging.Logger] = None
+    ):
         self._metadata = metadata
+        self.logger = logger or logging.getLogger(__name__)
     
     @property
     def metadata(self) -> RuleMetadata:
@@ -42,9 +48,13 @@ async def scan(
 class PluginManager:
     """Manages scanner plugins and their lifecycle"""
     
-    def __init__(self):
+    def __init__(
+        self,
+        logger: Optional[logging.Logger] = None
+    ):
         self.plugins: Dict[str, ScannerPlugin] = {}
         self.enabled_plugins: Set[str] = set()
+        self.logger = logger or logging.getLogger(__name__)
     
     async def register_plugin(
         self, 
diff --git a/valkyrie/plugins/vulnera/__init__.py b/valkyrie/plugins/vulnera/__init__.py
new file mode 100644
index 0000000..354a67d
--- /dev/null
+++ b/valkyrie/plugins/vulnera/__init__.py
@@ -0,0 +1,172 @@
+import hashlib
+from pathlib import Path
+from typing import Dict, List, Any
+
+from valkyrie.plugins import BaseSecurityRule
+from valkyrie.core.types import (
+    ScanRule, ScannerPlugin, RuleMetadata, SecurityFinding, 
+    FileLocation, SeverityLevel, FindingCategory,
+)
+
+from .conf import VulnerabilityInfo
+from .parser import parse_dependencies, is_supported
+
+
+####
+##      VULNERABILITY RULE
+#####
+class DependencyVulnerabilityRule(BaseSecurityRule):
+    """Rule for detecting vulnerable dependencies"""
+    
+    def __init__(
+        self, 
+        vulnerability_db: Dict[str, List[VulnerabilityInfo]]
+    ):
+        metadata = RuleMetadata(
+            id = "deps-001",
+            name = "Dependency Vulnerability Scanner",
+            description = "Scans dependencies for known vulnerabilities",
+            category = FindingCategory.DEPENDENCIES,
+            severity = SeverityLevel.HIGH,
+            author = "Valkyrie Core Team",
+            tags = {"dependencies", "vulnerabilities", "sbom"}
+        )
+        super().__init__(metadata)
+        self.vulnerability_db = vulnerability_db
+    
+    def is_applicable(self, file_path: Path) -> bool:
+        """Check if file is a supported dependency manifest"""
+
+        return is_supported(file_path)
+    
+    async def scan(
+        self, 
+        file_path: Path, 
+        content: str
+    ) -> List[SecurityFinding]:
+        """Scan dependency file for vulnerabilities."""
+
+        findings = []
+        
+        try:
+            dependencies = await self._parse_dependencies(file_path)
+            
+            for dep_name, version in dependencies.items():
+                if dep_name in self.vulnerability_db:
+                    vulnerabilities = self.vulnerability_db[dep_name]
+                    
+                    for vuln in vulnerabilities:
+                        if self._is_version_affected(version, vuln.affected_versions):
+
+                            # Then add it to findings
+                            finding = SecurityFinding(
+                                id = hashlib.md5(f"{file_path}:{dep_name}:{vuln.cve_id}".encode()).hexdigest(),
+                                title = f"Vulnerable dependency: {dep_name}",
+                                description = f"Dependency {dep_name}@{version} has vulnerability {vuln.cve_id}: {vuln.description}",
+                                severity = vuln.severity,
+                                category = self.metadata.category,
+                                location = FileLocation(file_path=file_path, line_number=1),
+                                rule_id = self.metadata.id,
+                                confidence = 0.9,
+                                metadata = {
+                                    "dependency": dep_name,
+                                    "version": version,
+                                    "cve_id": vuln.cve_id,
+                                    "fixed_versions": vuln.fixed_versions,
+                                    "references": vuln.references
+                                },
+                                remediation_advice = (
+                                    f"Update {dep_name} to version "
+                                    f"{', '.join(vuln.fixed_versions) if vuln.fixed_versions else 'latest'}"
+                                )
+                            )
+                            findings.append(finding)
+        
+        except Exception as e:
+            # Log parsing error but don't fail the scan
+            self.logger.warning(
+                f'Error scanning file {file_path}: {e}'
+            )
+        
+        return findings
+    
+    async def _parse_dependencies(self, file_path: Path) -> Dict[str, str]:
+        """Parse dependencies from file content"""
+
+        dependencies = {}
+        
+        # Parse the dependency file
+        for dep in parse_dependencies(file_path=file_path):
+            dependencies[dep.name] = dep.version
+        
+        return dependencies
+    
+    def _is_version_affected(
+        self, 
+        version: str, 
+        affected_versions: List[str]
+    ) -> bool:
+        """Check if version is affected by vulnerability"""
+        # Simplified version comparison for now
+        # I'll use a proper semver library in next push
+        return version in affected_versions
+
+
+####
+##      VULNERABILITY PLUGIN
+#####
+class DependenciesPlugin(ScannerPlugin):
+    """Plugin for dependency vulnerability scanning"""
+    
+    def __init__(self):
+        self.vulnerability_db: Dict[str, List[VulnerabilityInfo]] = {}
+    
+    @property
+    def name(self) -> str:
+        return "vulnera"
+    
+    @property
+    def version(self) -> str:
+        return "1.0.0"
+    
+    async def initialize(self, config: Dict[str, Any]) -> None:
+        """Initialize plugin and load vulnerability database"""
+        await self._load_vulnerability_db()
+    
+    async def _load_vulnerability_db(self) -> None:
+        """Load vulnerability database from external sources"""
+        
+        # Normally we need to call an external service 
+        # Or load a local vulnerabilities dbm
+        # but i'm usinng a mock database and
+        # i'll fix that in next push
+        self.vulnerability_db = {
+            "lodash": [
+                VulnerabilityInfo(
+                    cve_id="CVE-2021-23337",
+                    severity=SeverityLevel.HIGH,
+                    description="Prototype pollution in lodash",
+                    affected_versions=["4.17.20"],
+                    fixed_versions=["4.17.21"],
+                    references=["https://nvd.nist.gov/vuln/detail/CVE-2021-23337"]
+                )
+            ],
+            "requests": [
+                VulnerabilityInfo(
+                    cve_id="CVE-2023-32681",
+                    severity=SeverityLevel.MEDIUM,
+                    description="Certificate verification bypass in requests",
+                    affected_versions=["2.30.0", "2.29.0"],
+                    fixed_versions=["2.31.0"],
+                    references=["https://nvd.nist.gov/vuln/detail/CVE-2023-32681"]
+                )
+            ]
+        }
+    
+    async def get_rules(self) -> List[ScanRule]:
+        """Return dependency scanning rules"""
+        return [DependencyVulnerabilityRule(self.vulnerability_db)]
+    
+    async def cleanup(self) -> None:
+        """Cleanup plugin resources"""
+        pass
diff --git a/valkyrie/plugins/vulnera/conf.py b/valkyrie/plugins/vulnera/conf.py
new file mode 100644
index 0000000..196d9ca
--- /dev/null
+++ b/valkyrie/plugins/vulnera/conf.py
@@ -0,0 +1,60 @@
+from typing import List, Optional
+from dataclasses import dataclass, field
+from valkyrie.core.types import (
+    SeverityLevel
+)
+
+
+####
+##      VULNERABILITY MODEL
+#####
+@dataclass
+class VulnerabilityInfo:
+    """Information about a vulnerability"""
+    
+    cve_id: str
+    severity: SeverityLevel
+    description: str
+    affected_versions: List[str]
+    fixed_versions: List[str] = field(default_factory=list)
+    references: List[str] = field(default_factory=list)
+
+
+####
+##      DEPENDENCY MODEL
+#####
+@dataclass
+class Dependency:
+    """Project dependency rpresentation model"""
+
+    name: str
+    version: Optional[str] = None
+    dev: bool = False
+    source: Optional[str] = None 
+    
+    def __str__(self):
+        version_str = f"@{self.version}" if self.version else ""
+        dev_str = " (dev)" if self.dev else ""
+        return f"{self.name}{version_str}{dev_str}"
+
+
+####    DEPENDENCIES
+DEPS_FIES = {
+    # Node.js
+    'package.json', 'package-lock.json', 'yarn.lock',
+
+    # Python
+    'requirements.txt', 'Pipfile', 'Pipfile.lock', 'poetry.lock',
+
+    # Java
+    'pom.xml', 'gradle.build',
+
+    # Rust
+    'Cargo.toml', 'Cargo.lock',
+
+    # Go
+    'go.mod', 'go.sum',
+
+    # PHP
+    'composer.json', 'composer.lock'
+}
diff --git a/valkyrie/plugins/vulnera/parser.py b/valkyrie/plugins/vulnera/parser.py
new file mode 100644
index 0000000..9d1621d
--- /dev/null
+++ b/valkyrie/plugins/vulnera/parser.py
@@ -0,0 +1,652 @@
+"""
+Valkyrie vulnera plugin dependency parser module.
+"""
+
+import json
+import re
+import xml.etree.ElementTree as ET
+from pathlib import Path
+from typing import Dict, List, Optional, Union, Type
+import toml
+
+from .conf import Dependency
+
+
+####
+##      DEPENDENCY PARSER ERROR CLASS
+#####
+class DependencyParserError(Exception):
+    """Exception raised when an error occurs in dependency file parsing."""
+    pass
+
+
+####
+##      BASE DEPENDENCY PARSER
+#####
+class BaseDependencyParser:
+    """Base calss for all dependenccy parsers."""
+    
+    def __init__(self, file_path: Union[str, Path]):
+        self.file_path = Path(file_path)
+
+        if not self.file_path.exists():
+            raise FileNotFoundError(
+                f"The {self.file_path} file doesn't exist."
+            )
+        
+    @property
+    def dep_file(self) -> str:
+        raise NotImplementedError(
+            "'dep_file' property must be implemented in all subclasses."
+        )
+    
+    def parse(self) -> List[Dependency]:
+        """Parse a dependency file and return a deps list"""
+
+        raise NotImplementedError(
+            "Parse method must be implemented in all subclasses."
+        )
+    
+    def _read_file(self) -> str:
+        """Read and returns a dependency file content."""
+
+        try:
+            with open(self.file_path, 'r', encoding='utf-8') as f:
+                return f.read()
+            
+        except UnicodeDecodeError:
+            # Fallback for files with different encoding
+            with open(self.file_path, 'r', encoding='latin-1') as f:
+                return f.read()
+            
+
+####
+##      MAIN DEPENDENCY PARSER
+#####
+class DependencyParser:
+    """Main dependency parser"""
+    
+    _PARSERS: Dict[str,Type[BaseDependencyParser]] = {}
+
+    @classmethod
+    def register(cls, name: Optional[str] = None) -> None: # type: ignore
+        """Register a new Parser class."""
+
+        def wrapper(adapter: Type[BaseDependencyParser]):
+            """Wrapper"""
+
+            nonlocal name
+            name = name or adapter.dep_file
+            name = name.upper()
+            if name not in cls._PARSERS.keys():
+                cls._registry[name] = adapter
+                
+            return adapter
+
+        return wrapper
+    
+    @classmethod
+    def get(cls, name: str) -> Type[BaseDependencyParser]: # type: ignore
+        """Get a Parser class by its name."""
+
+        if name not in cls._registry:
+            raise DependencyParserError(
+                f"Invalid Parser name: '{name}' not found."
+                )
+        
+        return cls._PARSERS[name]
+    
+    @classmethod
+    def all(cls) -> List[Type[BaseDependencyParser]]: # type: ignore
+        """Get all registered Parsers classes."""
+        return list(cls._PARSERS.values())
+
+    @classmethod
+    def clear(cls) -> None:
+        """Clear the registry."""
+        cls._PARSERS.clear()
+
+    @classmethod
+    def get_supported_files(cls) -> List[str]:
+        """List all registered Parsers names."""
+        return list(cls._PARSERS.keys())
+    
+    @classmethod
+    def parse(cls, file_path: Union[str, Path]) -> List[Dependency]:
+        """
+        Parse a dependency file and return a dependencies list
+        
+        Args:
+            file_path: path to the dependency file
+            
+        Returns:
+            List of dependencies
+            
+        Raises:
+            DependencyParserError: if file format is not supported
+            FileNotFoundError: if hthe file doesn't exist        
+        """
+
+        file_path = Path(file_path)
+        filename = file_path.name
+        
+        if filename not in cls._PARSERS:
+            raise DependencyParserError(
+                f"Usupported file format: {filename}. "
+                f"Supported format are: {', '.join(cls._PARSERS.keys())}"
+            )
+        
+        parser_class = cls.get(filename)
+        parser = parser_class(file_path)
+        
+        try:
+            return parser.parse()
+        except Exception as e:
+            raise DependencyParserError(
+                f"Error when parsing {filename}: {str(e)}"
+            ) from e
+    
+    @classmethod
+    def is_supported(cls, file_path: Union[str, Path]) -> bool:
+        """check if a file is supported."""
+
+        filename = Path(file_path).name
+        return filename in cls._PARSERS
+    
+
+####
+##      "Package.json" PARSER
+#####
+DependencyParser.register()
+class PackageJsonParser(BaseDependencyParser):
+    """Parser for package.json (Node.js)"""
+
+    @property
+    def dep_file(self):
+        return "package.json"
+    
+    def parse(self) -> List[Dependency]:
+        content = self._read_file()
+        data = json.loads(content)
+        
+        dependencies = []
+        
+        # Production
+        if 'dependencies' in data:
+            for name, version in data['dependencies'].items():
+                dependencies.append(Dependency(name, version, dev=False))
+        
+        # Developement
+        if 'devDependencies' in data:
+            for name, version in data['devDependencies'].items():
+                dependencies.append(Dependency(name, version, dev=True))
+        
+        return dependencies
+    
+
+####
+##      "package-lock.json" PARSER
+#####
+DependencyParser.register()
+class PackageLockParser(BaseDependencyParser):
+    """Parser foor package-lock.json (Node.js)"""
+
+    @property
+    def dep_file(self):
+        return "package-lock.json"
+    
+    def parse(self) -> List[Dependency]:
+        content = self._read_file()
+        data = json.loads(content)
+        
+        dependencies = []
+        
+        # Format npm v7+
+        if 'packages' in data:
+            for path, info in data['packages'].items():
+                if path == "":  # Skip root package
+                    continue
+
+                name = path.replace('node_modules/', '')
+                version = info.get('version')
+                is_dev = info.get('dev', False)
+                dependencies.append(Dependency(name, version, dev=is_dev))
+
+        # Format npm v6
+        elif 'dependencies' in data:
+            for name, info in data['dependencies'].items():
+                version = info.get('version')
+                is_dev = info.get('dev', False)
+                dependencies.append(Dependency(name, version, dev=is_dev))
+        
+        return dependencies
+    
+
+####
+##      "yarn.lock" PARSER
+#####
+DependencyParser.register()
+class YarnLockParser(BaseDependencyParser):
+    """Parser for yarn.lock (Node.js)"""
+
+    @property
+    def dep_file(self):
+        return "yarn.lock"
+    
+    def parse(self) -> List[Dependency]:
+        content = self._read_file()
+        dependencies = []
+        
+        # yarn.lock entries matching pattern
+        pattern = r'^([^#\s][^:]*?):\s*\n(?:\s+.*\n)*?\s+version\s+"([^"]+)"'
+        matches = re.findall(pattern, content, re.MULTILINE)
+        
+        seen = set()
+        for name_pattern, version in matches:
+            # Extract package name (before @)
+            name = re.split(r'@(?=\d)', name_pattern.split(',')[0].strip())[0].strip('"')
+            if name not in seen:
+                dependencies.append(Dependency(name, version))
+                seen.add(name)
+        
+        return dependencies
+    
+
+####
+##      "requirements.txt" PARSER
+#####
+DependencyParser.register()
+class RequirementsTxtParser(BaseDependencyParser):
+    """Parser for requirements.txt (Python)"""
+
+    @property
+    def dep_file(self):
+        return "requirements.txt"
+    
+    def parse(self) -> List[Dependency]:
+        content = self._read_file()
+        dependencies = []
+        
+        for line in content.strip().split('\n'):
+            line = line.strip()
+            if not line or line.startswith('#'):
+                continue
+            
+            # Skip pip options like -r, -e, etc.
+            if line.startswith('-'):
+                continue
+            
+            # matching name==version, nane>=version, etc.
+            match = re.match(r'^([a-zA-Z0-9_.-]+)([><=!]*)(.*?)(?:\s*#.*)?$', line)
+            if match:
+                name = match.group(1)
+                operator = match.group(2)
+                version = match.group(3).strip() if match.group(3) else None
+                version_str = f"{operator}{version}" if version else None
+                dependencies.append(Dependency(name, version_str))
+        
+        return dependencies
+    
+
+####
+##      "Pipfile" PARSER
+#####
+DependencyParser.register()
+class PipfileParser(BaseDependencyParser):
+    """Parser for Pipfile (Python)"""
+
+    @property
+    def dep_file(self):
+        return "Pipfile"
+    
+    def parse(self) -> List[Dependency]:
+        content = self._read_file()
+        data = toml.loads(content)
+        
+        dependencies = []
+        
+        # Production
+        if 'packages' in data:
+            for name, version_info in data['packages'].items():
+                version = (
+                    version_info 
+                    if isinstance(version_info, str) 
+                    else version_info.get('version', '*')
+                )
+                dependencies.append(Dependency(name, version, dev=False))
+        
+        # Developement
+        if 'dev-packages' in data:
+            for name, version_info in data['dev-packages'].items():
+                version = (
+                    version_info 
+                    if isinstance(version_info, str) 
+                    else version_info.get('version', '*')
+                )
+                dependencies.append(Dependency(name, version, dev=True))
+        
+        return dependencies
+
+
+####
+##      "Pipfile.lock" PARSER
+#####
+DependencyParser.register()
+class PipfileLockParser(BaseDependencyParser):
+    """Parser for Pipfile.lock (Python)"""
+
+    @property
+    def dep_file(self):
+        return "Pipfile.lock"
+    
+    def parse(self) -> List[Dependency]:
+        content = self._read_file()
+        data = json.loads(content)
+        
+        dependencies = []
+        
+        # Production
+        if 'default' in data:
+            for name, info in data['default'].items():
+                version = info.get('version', '').replace('==', '')
+                dependencies.append(Dependency(name, version, dev=False))
+        
+        # Developement
+        if 'develop' in data:
+            for name, info in data['develop'].items():
+                version = info.get('version', '').replace('==', '')
+                dependencies.append(Dependency(name, version, dev=True))
+        
+        return dependencies
+    
+
+####
+##      "poetry.lock" PARSER
+#####
+DependencyParser.register()
+class PoetryLockParser(BaseDependencyParser):
+    """Parser for poetry.lock (Python)"""
+
+    @property
+    def dep_file(self):
+        return "poetry.lock"
+    
+    def parse(self) -> List[Dependency]:
+        content = self._read_file()
+        data = toml.loads(content)
+        
+        dependencies = []
+        
+        if 'package' in data:
+            for package in data['package']:
+                name = package.get('name')
+                version = package.get('version')
+                category = package.get('category', 'main')
+                is_dev = category == 'dev'
+                dependencies.append(Dependency(name, version, dev=is_dev))
+        
+        return dependencies
+    
+
+####
+##      "pom.xml" PARSER
+#####
+DependencyParser.register()
+class PomXmlParser(BaseDependencyParser):
+    """Parser for pom.xml (Java/Maven)"""
+
+    @property
+    def dep_file(self):
+        return "pom.xml"
+    
+    def parse(self) -> List[Dependency]:
+        content = self._read_file()
+        root = ET.fromstring(content)
+        
+        # Maven namespaces
+        namespaces = {'maven': 'http://maven.apache.org/POM/4.0.0'}
+        if root.tag.startswith('{'):
+            ns = root.tag.split('}')[0] + '}'
+            namespaces['maven'] = ns[1:-1]
+        
+        dependencies = []
+        
+        # Find all dependencies
+        for dep in root.findall('.//maven:dependency', namespaces) or root.findall('.//dependency'):
+            group_id = dep.find('maven:groupId', namespaces) or dep.find('groupId')
+            artifact_id = dep.find('maven:artifactId', namespaces) or dep.find('artifactId')
+            version = dep.find('maven:version', namespaces) or dep.find('version')
+            scope = dep.find('maven:scope', namespaces) or dep.find('scope')
+            
+            if group_id is not None and artifact_id is not None:
+                name = f"{group_id.text}:{artifact_id.text}"
+                version_str = version.text if version is not None else None
+                is_dev = scope is not None and scope.text in ['test', 'provided']
+                dependencies.append(Dependency(name, version_str, dev=is_dev))
+        
+        return dependencies
+    
+
+####
+##      "build.gradle" PARSER
+#####
+DependencyParser.register()
+class GradleBuildParser(BaseDependencyParser):
+    """Parser for build.gradle (Java/Gradle)"""
+
+    @property
+    def dep_file(self):
+        return "build.gradle"
+    
+    def parse(self) -> List[Dependency]:
+        content = self._read_file()
+        dependencies = []
+        
+        # Gradle deppendenciees matching pattern
+        patterns = [
+            r"(?:implementation|compile|api|testImplementation|testCompile)\s+['\"]([^:]+):([^:]+):([^'\"]+)['\"]",
+            r"(?:implementation|compile|api|testImplementation|testCompile)\s+group:\s*['\"]([^'\"]+)['\"],\s*name:\s*['\"]([^'\"]+)['\"],\s*version:\s*['\"]([^'\"]+)['\"]"
+        ]
+        
+        for pattern in patterns:
+            matches = re.findall(pattern, content)
+            for match in matches:
+                if len(match) == 3:
+                    group_id, artifact_id, version = match
+                    name = f"{group_id}:{artifact_id}"
+                    dependencies.append(Dependency(name, version))
+        
+        return dependencies
+    
+
+####
+##      "Cargo.toml" PARSER
+#####
+DependencyParser.register()
+class CargoTomlParser(BaseDependencyParser):
+    """Parser for Cargo.toml (Rust)"""
+
+    @property
+    def dep_file(self):
+        return "Cargo.toml"
+    
+    def parse(self) -> List[Dependency]:
+        content = self._read_file()
+        data = toml.loads(content)
+        
+        dependencies = []
+        
+        # Production
+        if 'dependencies' in data:
+            for name, version_info in data['dependencies'].items():
+                version = version_info if isinstance(version_info, str) else version_info.get('version')
+                dependencies.append(Dependency(name, version, dev=False))
+        
+        # Developpement
+        if 'dev-dependencies' in data:
+            for name, version_info in data['dev-dependencies'].items():
+                version = version_info if isinstance(version_info, str) else version_info.get('version')
+                dependencies.append(Dependency(name, version, dev=True))
+        
+        return dependencies
+    
+
+####
+##      "Cargo.lock" PARSER
+#####
+DependencyParser.register()
+class CargoLockParser(BaseDependencyParser):
+    """Parser for Cargo.lock (Rust)"""
+
+    @property
+    def dep_file(self):
+        return "Cargo.lock"
+    
+    def parse(self) -> List[Dependency]:
+        content = self._read_file()
+        data = toml.loads(content)
+        
+        dependencies = []
+        
+        if 'package' in data:
+            for package in data['package']:
+                name = package.get('name')
+                version = package.get('version')
+                dependencies.append(Dependency(name, version))
+        
+        return dependencies
+    
+
+####
+##      "go.mod" PARSER
+#####
+DependencyParser.register()
+class GoModParser(BaseDependencyParser):
+    """Parser for go.mod (Go)"""
+
+    @property
+    def dep_file(self):
+        return "go.mod"
+    
+    def parse(self) -> List[Dependency]:
+        content = self._read_file()
+        dependencies = []
+        
+        # Required matching pattern
+        in_require = False
+        for line in content.split('\n'):
+            line = line.strip()
+            
+            if line.startswith('require ('):
+                in_require = True
+                continue
+            elif line == ')' and in_require:
+                in_require = False
+                continue
+            
+            if in_require or line.startswith('require '):
+                # Clean the line
+                line = line.replace('require ', '').strip()
+                if not line or line == '(':
+                    continue
+                
+                # Match module version
+                parts = line.split()
+                if len(parts) >= 2:
+                    module = parts[0]
+                    version = parts[1]
+                    dependencies.append(Dependency(module, version))
+        
+        return dependencies
+    
+
+####
+##      "composer.json" PARSER
+#####
+DependencyParser.register()
+class ComposerJsonParser(BaseDependencyParser):
+    """Parser for composer.json (PHP)"""
+
+    @property
+    def dep_file(self):
+        return "composer.json"
+    
+    def parse(self) -> List[Dependency]:
+        content = self._read_file()
+        data = json.loads(content)
+        
+        dependencies = []
+        
+        # Production
+        if 'require' in data:
+            for name, version in data['require'].items():
+                if name != 'php':  # Exclude PHP version
+                    dependencies.append(Dependency(name, version, dev=False))
+        
+        # Developement
+        if 'require-dev' in data:
+            for name, version in data['require-dev'].items():
+                dependencies.append(Dependency(name, version, dev=True))
+        
+        return dependencies
+    
+
+####
+##      "composer.lock" PARSER
+#####
+DependencyParser.register()
+class ComposerLockParser(BaseDependencyParser):
+    """Parser pour composer.lock (PHP)"""
+
+    @property
+    def dep_file(self):
+        return "composer.lock "
+    
+    def parse(self) -> List[Dependency]:
+        content = self._read_file()
+        data = json.loads(content)
+        
+        dependencies = []
+        
+        # Production
+        if 'packages' in data:
+            for package in data['packages']:
+                name = package.get('name')
+                version = package.get('version')
+                dependencies.append(Dependency(name, version, dev=False))
+        
+        # Developement
+        if 'packages-dev' in data:
+            for package in data['packages-dev']:
+                name = package.get('name')
+                version = package.get('version')
+                dependencies.append(Dependency(name, version, dev=True))
+        
+        return dependencies
+
+
+####    DEPENDENCY PARSER UTILITY FFUNCTION
+def parse_dependencies(file_path: Union[str, Path]) -> List[Dependency]:
+    """
+    Utillity funnction for dependency files parsing
+    
+    Args:
+        file_path: depenedency file path
+        
+    Returns:
+        Dependency List
+    """
+    return DependencyParser.parse(file_path)
+
+###     IS DEP FILE SUPPORTED
+def is_supported(file_path: Union[str,Path]) -> bool:
+    """
+    Check if the file is a supported dependency manifest
+    
+    Args:
+        file_path: depenedency file path
+        
+    Returns:
+        True if file is upported else False
+    """
+    return DependencyParser.is_supported(file_path)

From bdc5a048db54d3c79f7338a80a43ef9dd34da158 Mon Sep 17 00:00:00 2001
From: Einswilli <wilfriedgoeh@gmail.com>
Date: Thu, 11 Sep 2025 18:49:23 +0200
Subject: [PATCH 15/17] valkyrie,plugins: Fix typo in Vulnera.parser

---
 valkyrie/plugins/vulnera/parser.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/valkyrie/plugins/vulnera/parser.py b/valkyrie/plugins/vulnera/parser.py
index 9d1621d..0a1b22d 100644
--- a/valkyrie/plugins/vulnera/parser.py
+++ b/valkyrie/plugins/vulnera/parser.py
@@ -189,7 +189,7 @@ def parse(self) -> List[Dependency]:
 #####
 DependencyParser.register()
 class PackageLockParser(BaseDependencyParser):
-    """Parser foor package-lock.json (Node.js)"""
+    """Parser for package-lock.json (Node.js)"""
 
     @property
     def dep_file(self):
@@ -596,7 +596,7 @@ def parse(self) -> List[Dependency]:
 #####
 DependencyParser.register()
 class ComposerLockParser(BaseDependencyParser):
-    """Parser pour composer.lock (PHP)"""
+    """Parser for composer.lock (PHP)"""
 
     @property
     def dep_file(self):

From fd7fb9faced5c5dd038689495c4896e6cb6af048 Mon Sep 17 00:00:00 2001
From: Einswilli <wilfriedgoeh@gmail.com>
Date: Fri, 12 Sep 2025 15:53:32 +0200
Subject: [PATCH 16/17] valkkyrie.plugins: Add iamx plugin foor IAM
 configuration Scanning

---
 valkyrie/plugins/iamx/__init__.py    | 139 +++++++++++++++++++++++++++
 valkyrie/plugins/iamx/conf.py        |  62 ++++++++++++
 valkyrie/plugins/secrets/__init__.py |   8 +-
 valkyrie/plugins/vulnera/__init__.py |   2 +-
 4 files changed, 207 insertions(+), 4 deletions(-)
 create mode 100644 valkyrie/plugins/iamx/__init__.py
 create mode 100644 valkyrie/plugins/iamx/conf.py

diff --git a/valkyrie/plugins/iamx/__init__.py b/valkyrie/plugins/iamx/__init__.py
new file mode 100644
index 0000000..b1a34db
--- /dev/null
+++ b/valkyrie/plugins/iamx/__init__.py
@@ -0,0 +1,139 @@
+import hashlib
+from pathlib import Path
+from typing import Dict, List, Any
+
+from valkyrie.plugins import BaseSecurityRule
+from valkyrie.core.types import (
+    ScanRule, ScannerPlugin, RuleMetadata, SecurityFinding, 
+    FileLocation, SeverityLevel, FindingCategory,
+)
+
+from .conf import RISKY_PATTERNS
+
+
+####
+##      IAM CONFIGURATION RULE
+#####
+class IAMConfigurationRule(BaseSecurityRule):
+    """Rule for detecting risky IAM configurations"""
+    
+    def __init__(self):
+        metadata = RuleMetadata(
+            id = "iam-001",
+            name = "IAM Configuration Scanner",
+            description = "Detects overly permissive IAM policies and configurations",
+            category = FindingCategory.IAM_CONFIG,
+            severity = SeverityLevel.HIGH,
+            author = "Valkyrie Core Team",
+            tags = {"iam", "aws", "gcp", "azure", "permissions"}
+        )
+        super().__init__(metadata)
+        
+        # Define risky patterns
+        self.risky_patterns = RISKY_PATTERNS
+    
+    def is_applicable(self, file_path: Path) -> bool:
+        """Check if file contains IAM configurations"""
+
+        iam_files = {
+            '.json', '.yaml', '.yml', '.tf', '.hcl'
+        }
+        
+        if file_path.suffix.lower() not in iam_files:
+            return False
+        
+        # Check filename patterns
+        iam_patterns = [
+            'policy', 'iam', 'role', 'permission', 'access',
+            'cloudformation', 'terraform', 'main.tf'
+        ]
+        
+        filename_lower = file_path.name.lower()
+        return any(
+            pattern in filename_lower 
+            for pattern in iam_patterns
+        )
+    
+    async def scan(
+        self, 
+        file_path: Path, 
+        content: str
+    ) -> List[SecurityFinding]:
+        """Scan IAM configuration files"""
+
+        findings = []
+        lines = content.split('\n')
+        
+        for line_num, line in enumerate(lines, 1):
+            for pattern_info in self.risky_patterns:
+                matches = pattern_info.pattern.finditer(line)
+                
+                for match in matches:
+                    finding = SecurityFinding(
+                        id = hashlib.md5(f"{file_path}:{line_num}:{pattern_info.name}".encode()).hexdigest(),
+                        title = f"Risky IAM Configuration: {pattern_info.name}",
+                        description = pattern_info.description,
+                        severity = pattern_info.severity,
+                        category = self.metadata.category,
+                        location = FileLocation(
+                            file_path = file_path,
+                            line_number = line_num,
+                            column_start = match.start(),
+                            column_end = match.end()
+                        ),
+                        rule_id = self.metadata.id,
+                        confidence = 0.8,
+                        metadata={
+                            "pattern_name": pattern_info["name"],
+                            "line_content": line.strip(),
+                            "cloud_provider": self._detect_cloud_provider(content)
+                        },
+                        remediation_advice = (
+                            "Apply principle of least privilege. "
+                            "Specify exact resources and actions needed."
+                        )
+                    )
+                    findings.append(finding)
+        
+        return findings
+    
+    def _detect_cloud_provider(self, content: str) -> str:
+        """Detect cloud provider from content"""
+
+        content_lower = content.lower()
+        
+        if 'amazonaws.com' in content_lower or 'aws:' in content_lower:
+            return "AWS"
+        elif 'googleapis.com' in content_lower or 'gcp' in content_lower:
+            return "GCP"
+        elif 'azure' in content_lower or 'microsoft.com' in content_lower:
+            return "Azure"
+        else:
+            return "Unknown"
+
+
+####
+##      IAM CONFIGURATION PLUGIN
+#####
+class IAMPlugin(ScannerPlugin):
+    """Plugin for IAM configuration scanning"""
+    
+    @property
+    def name(self) -> str:
+        return "iam-scanner"
+    
+    @property
+    def version(self) -> str:
+        return "0.1.0"
+    
+    async def initialize(self, config: Dict[str, Any]) -> None:
+        """Initialize IAM plugin"""
+        pass
+    
+    async def get_rules(self) -> List[ScanRule]:
+        """Return IAM scanning rules"""
+        return [IAMConfigurationRule()]
+    
+    async def cleanup(self) -> None:
+        """Cleanup plugin resources"""
+        pass
diff --git a/valkyrie/plugins/iamx/conf.py b/valkyrie/plugins/iamx/conf.py
new file mode 100644
index 0000000..433ad50
--- /dev/null
+++ b/valkyrie/plugins/iamx/conf.py
@@ -0,0 +1,62 @@
+import re
+from dataclasses import dataclass
+from typing import (
+    List, Pattern, Optional
+)
+
+from valkyrie.core.types import SeverityLevel
+
+
+####
+##      SECRET PATTERN MODEL
+#####
+@dataclass
+class RiskyPattern:
+    """Pattern definition for secret detection"""
+
+    name: str
+    pattern: Pattern[str]
+    description: Optional[str] = None
+    severity: SeverityLevel = SeverityLevel.MEDIUM
+
+
+#### 
+RISKY_PATTERNS: List[RiskyPattern] = [
+    ## AMAZON WEB SERVICES (AWS)
+    RiskyPattern(
+        **{
+            "name": "AWS Wildcard Resource",
+            "pattern": re.compile(r'"Resource"\s*:\s*"\*"', re.IGNORECASE),
+            "description": "Policy allows access to all resources",
+            "severity": SeverityLevel.CRITICAL
+        },
+    ),
+    RiskyPattern(
+        **{
+            "name": "AWS Admin Access",
+            "pattern": re.compile(r'"Action"\s*:\s*"\*"', re.IGNORECASE),
+            "description": "Policy grants all actions (admin access)",
+            "severity": SeverityLevel.CRITICAL
+        },
+    ),
+
+    ## GOOGLE CLOUD (GCP)
+    RiskyPattern(
+        **{
+            "name": "GCP All Scopes",
+            "pattern": re.compile(r'https://www\.googleapis\.com/auth/cloud-platform', re.IGNORECASE),
+            "description": "Grants access to all Google Cloud Platform services",
+            "severity": SeverityLevel.HIGH
+        },
+    ),
+    
+    ## MICROSOFT AZURE
+    RiskyPattern(
+        **{
+            "name": "Azure Contributor Role",
+            "pattern": re.compile(r'"roleDefinitionId".*"b24988ac-6180-42a0-ab88-20f7382dd24c"', re.IGNORECASE),
+            "description": "Grants broad contributor access to Azure resources",
+            "severity": SeverityLevel.MEDIUM
+        }
+    )
+]
diff --git a/valkyrie/plugins/secrets/__init__.py b/valkyrie/plugins/secrets/__init__.py
index 0fd003f..fb9e45b 100644
--- a/valkyrie/plugins/secrets/__init__.py
+++ b/valkyrie/plugins/secrets/__init__.py
@@ -14,7 +14,7 @@
     FileLocation
 )
 
-from valkyrie.plugins.secrets.conf import (
+from .conf import (
     SECRETS_PATTERNS, SecretPattern
 )
 
@@ -82,11 +82,13 @@ async def scan(self, file_path: Path, content: str) -> List[SecurityFinding]:
         for line_num, line in enumerate(lines, 1):
             # Skip comments and obvious false positives
             line_lower = line.lower().strip()
-            if (line_lower.startswith('#') or 
+            if (
+                line_lower.startswith('#') or 
                 line_lower.startswith('//') or 
                 'example' in line_lower or 
                 'placeholder' in line_lower or 
-                'your_api_key_here' in line_lower):
+                'your_api_key_here' in line_lower
+            ):
                 continue
             
             for pattern in self.patterns:
diff --git a/valkyrie/plugins/vulnera/__init__.py b/valkyrie/plugins/vulnera/__init__.py
index 354a67d..f4619c3 100644
--- a/valkyrie/plugins/vulnera/__init__.py
+++ b/valkyrie/plugins/vulnera/__init__.py
@@ -127,7 +127,7 @@ def name(self) -> str:
     
     @property
     def version(self) -> str:
-        return "1.0.0"
+        return "0.1.0"
     
     async def initialize(self, config: Dict[str, Any]) -> None:
         """Initialize plugin and load vulnerability database"""

From a288baed82f8e30b9ff6fd16942f58ae992b719a Mon Sep 17 00:00:00 2001
From: Einswilli <wilfriedgoeh@gmail.com>
Date: Sat, 13 Sep 2025 12:40:16 +0200
Subject: [PATCH 17/17] Valkyrie.core: Add Scann Result Formatters base class
 and SARIF Formmater

---
 .gitignore                        |   2 +-
 pyproject.toml                    |  10 ++-
 valkyrie/core/formatters/base.py  |  14 ++++
 valkyrie/core/formatters/sarif.py | 128 ++++++++++++++++++++++++++++++
 valkyrie/plugins/__init__.py      |   1 +
 5 files changed, 151 insertions(+), 4 deletions(-)
 create mode 100644 valkyrie/core/formatters/base.py
 create mode 100644 valkyrie/core/formatters/sarif.py

diff --git a/.gitignore b/.gitignore
index c85fc4a..bd92954 100644
--- a/.gitignore
+++ b/.gitignore
@@ -211,4 +211,4 @@ __marimo__/
 docs/*
 rules/*
 tests/*
-# valkyrie/*
+valkyrie/repositories/*
diff --git a/pyproject.toml b/pyproject.toml
index 29822f4..788eec5 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -9,9 +9,13 @@ maintainers = [{ name = "#Einswilli", email = "einswilligoeh@email.com" }]
 requires-python = ">=3.10"
 keywords = [
     "valkyrie", "CI/CD", "security scaner", "guardian",
-    "pipelines"
+    "pipelines", "iam", "secrets"
+]
+dependencies = [
+    "toml>=0.10.2",
+    "tomli>=2.2.1",
+    "yamllib>=0.0.1",
 ]
-dependencies = []
 
 [project.optional-dependencies]
 dev = [
@@ -38,4 +42,4 @@ packages = ["valkyrie"]
 
 [build-system]
 requires = ["setuptools>=61.0", "wheel"]
-build-backend = "setuptools.build_meta"
\ No newline at end of file
+build-backend = "setuptools.build_meta"
diff --git a/valkyrie/core/formatters/base.py b/valkyrie/core/formatters/base.py
new file mode 100644
index 0000000..a911ddf
--- /dev/null
+++ b/valkyrie/core/formatters/base.py
@@ -0,0 +1,14 @@
+from abc import ABC, abstractmethod
+
+from valkyrie.core.types import ScanResult
+
+####
+##      SCAN RESULT FORMATTERS BASE CLASS
+#####
+class ResultFormatter(ABC):
+    """Abstract base class for result formatting"""
+    
+    @abstractmethod
+    def format(self, result: ScanResult) -> str:
+        """Format scan result to string"""
+        pass
\ No newline at end of file
diff --git a/valkyrie/core/formatters/sarif.py b/valkyrie/core/formatters/sarif.py
new file mode 100644
index 0000000..4227fe6
--- /dev/null
+++ b/valkyrie/core/formatters/sarif.py
@@ -0,0 +1,128 @@
+"""
+Valkyrie - SARIF Scan result Foormatter
+"""
+
+import json
+from typing import List, Dict, Any
+from valkyrie.core.types import (
+    ScanResult, ScanStatus, SecurityFinding,
+    SeverityLevel
+)
+from .base import ResultFormatter
+
+
+####
+##      SARIF SCAN RESUT FORMATTER
+#####
+class SARIFFormatter(ResultFormatter):
+    """SARIF (Static Analysis Results Interchange Format) formatter"""
+    
+    def format(self, result: ScanResult) -> str:
+        """Format results as SARIF JSON"""
+
+        sarif_report = {
+            "version": "2.1.0",
+            "$schema": "https://schemastore.azurewebsites.net/schemas/json/sarif-2.1.0.json",
+            "runs": [
+                {
+                    "tool": {
+                        "driver": {
+                            "name": "Valkyrie",
+                            "version": "1.0.0",
+                            "informationUri": "https://github.com/valkyrie-scanner/valkyrie",
+                            "rules": self._generate_rules(result.findings)
+                        }
+                    },
+                    "results": self._generate_results(result.findings),
+                    "invocations": [
+                        {
+                            "executionSuccessful": result.status == ScanStatus.COMPLETED,
+                            "startTimeUtc": result.timestamp.isoformat() + "Z",
+                            "endTimeUtc": result.timestamp.isoformat() + "Z"
+                        }
+                    ]
+                }
+            ]
+        }
+        
+        return json.dumps(sarif_report, indent=2)
+    
+    def _generate_rules(
+        self, 
+        findings: List[SecurityFinding]
+    ) -> List[Dict[str, Any]]:
+        """Generate SARIF rules from findings"""
+
+        rules = {}
+        
+        for finding in findings:
+            if finding.rule_id not in rules:
+                rules[finding.rule_id] = {
+                    "id": finding.rule_id,
+                    "shortDescription": {"text": finding.title},
+                    "fullDescription": {"text": finding.description},
+                    "help": {
+                        "text": finding.remediation_advice or "Review and fix the security issue"
+                    },
+                    "properties": {
+                        "security-severity": self._severity_to_score(finding.severity)
+                    }
+                }
+        
+        return list(rules.values())
+    
+    def _generate_results(
+        self, 
+        findings: List[SecurityFinding]
+    ) -> List[Dict[str, Any]]:
+        """Generate SARIF results from findings"""
+
+        results = []
+        
+        for finding in findings:
+            result = {
+                "ruleId": finding.rule_id,
+                "message": {"text": finding.description},
+                "level": self._severity_to_level(finding.severity),
+                "locations": [
+                    {
+                        "physicalLocation": {
+                            "artifactLocation": {
+                                "uri": str(finding.location.file_path)
+                            },
+                            "region": {
+                                "startLine": finding.location.line_number,
+                                "startColumn": finding.location.column_start,
+                                "endColumn": finding.location.column_end
+                            }
+                        }
+                    }
+                ]
+            }
+            results.append(result)
+        
+        return results
+    
+    def _severity_to_level(self, severity: SeverityLevel) -> str:
+        """Convert severity to SARIF level"""
+
+        mapping = {
+            SeverityLevel.CRITICAL: "error",
+            SeverityLevel.HIGH: "error",
+            SeverityLevel.MEDIUM: "warning",
+            SeverityLevel.LOW: "note",
+            SeverityLevel.INFO: "note"
+        }
+        return mapping.get(severity, "note")
+    
+    def _severity_to_score(self, severity: SeverityLevel) -> str:
+        """Convert severity to security score"""
+        
+        mapping = {
+            SeverityLevel.CRITICAL: "9.0",
+            SeverityLevel.HIGH: "7.0",
+            SeverityLevel.MEDIUM: "5.0",
+            SeverityLevel.LOW: "3.0",
+            SeverityLevel.INFO: "1.0"
+        }
+        return mapping.get(severity, "1.0")
diff --git a/valkyrie/plugins/__init__.py b/valkyrie/plugins/__init__.py
index 4818cd4..45df10a 100644
--- a/valkyrie/plugins/__init__.py
+++ b/valkyrie/plugins/__init__.py
@@ -1,4 +1,5 @@
 """
+Valkyrie - Plugin module.
 """
 from pathlib import Path
 from typing import List, Set, Dict, Any, Optional