!

Author: Tuntii

.gitignore

@@ -177,3 +177,4 @@ openaudit.egg-info/PKG-INFO
 openaudit.egg-info/requires.txt
 openaudit.egg-info/SOURCES.txt
 openaudit.egg-info/top_level.txt
+/plans

.openaudit/custom_rules.yaml

@@ -0,0 +1,63 @@
+# OpenAuditKit Custom Rules Template
+# Place this file in:
+#   - Project root: .openaudit/custom_rules.yaml
+#   - Home directory: ~/.openaudit/custom_rules.yaml
+#
+# Rules will be automatically loaded and merged with built-in rules.
+
+rules:
+  # Example: Detect specific company-wide patterns
+  - id: "CUSTOM_COMPANY_API_KEY"
+    description: "Company-specific API key pattern detected"
+    regex: "MYCOMPANY_API_[A-Za-z0-9]{32}"
+    entropy_check: false
+    severity: "high"
+    confidence: "high"
+    category: "secret"
+    remediation: "Move to environment variables or secrets manager."
+
+  # Example: Detect internal function misuse
+  - id: "CUSTOM_DEPRECATED_FUNCTION"
+    description: "Deprecated internal function usage"
+    regex: "legacy_auth\\(|old_database_connect\\("
+    severity: "medium"
+    confidence: "high"
+    category: "technical_debt"
+    remediation: "Migrate to the new authentication/database API."
+
+  # Example: Detect hardcoded internal URLs
+  - id: "CUSTOM_INTERNAL_URL"
+    description: "Hardcoded internal service URL"
+    regex: "https?://(dev|staging|internal)\\.(mycompany|example)\\.com"
+    severity: "medium"
+    confidence: "medium"
+    category: "config"
+    remediation: "Use environment-based configuration."
+
+  # Example: Detect insecure coding patterns
+  - id: "CUSTOM_EVAL_USAGE"
+    description: "Usage of eval() or exec() detected"
+    regex: "\\beval\\(|\\bexec\\("
+    severity: "critical"
+    confidence: "high"
+    category: "security"
+    remediation: "Avoid eval/exec. Use safer alternatives like ast.literal_eval()."
+
+  # Example: Detect TODO patterns with specific team tags
+  - id: "CUSTOM_BLOCKED_TODO"
+    description: "Blocked TODO found (requires immediate attention)"
+    regex: "TODO:\\s*BLOCKED:"
+    severity: "high"
+    confidence: "high"
+    category: "technical_debt"
+    remediation: "Resolve the blocking issue or escalate to team lead."
+
+  # Example: Entropy-based secret detection
+  - id: "CUSTOM_HIGH_ENTROPY_SECRET"
+    description: "High-entropy string that might be a secret"
+    regex: "secret[_-]?key[\"']?\\s*[:=]\\s*[\"']([A-Za-z0-9+/=]{20,})[\"']"
+    entropy_check: true
+    severity: "high"
+    confidence: "medium"
+    category: "secret"
+    remediation: "Verify if this is a real secret. If yes, move to secrets manager."

README.md

@@ -111,6 +111,36 @@ Prevent security issues from being committed by using our pre-configured git hoo
 
 Now, `openaudit` will automatically scan your code before every commit!
 
+## 🎨 Custom Rules ("Vibe Checks")
+
+Define your own security and quality rules that match your team's standards.
+
+1.  **Create a custom rules file**:
+    ```bash
+    openaudit custom-rules init
+    ```
+
+2.  **Edit the generated file** (`.openaudit/custom_rules.yaml`):
+    ```yaml
+    rules:
+      - id: "CUSTOM_COMPANY_SECRET"
+        description: "Company API key detected"
+        regex: "MYCOMPANY_[A-Z0-9]{32}"
+        severity: "high"
+        confidence: "high"
+        category: "secret"
+        remediation: "Move to secrets manager."
+    ```
+
+3.  **Run scan** - Custom rules are automatically loaded:
+    ```bash
+    openaudit scan .
+    ```
+
+Custom rules can be placed in:
+- **Project-level**: `.openaudit/custom_rules.yaml` (committed to repo)
+- **User-level**: `~/.openaudit/custom_rules.yaml` (personal rules)
+
 ## 🛡️ VibeGuard (Tech Debt Scanner)
 
 We know "vibecodin" happens. OpenAuditKit now includes **VibeGuard**, a scanner designed to catch non-engineering practices before they hit production:

memory_bank.md

@@ -42,6 +42,12 @@
 - **Implementation**: Added `.pre-commit-config.yaml` and `pre-commit` dev dependency.
 - **Usage**: `pre-commit install` sets up the hook.
 
+### 6. Custom Rules System 🎨
+- **Objective**: Allow users to define custom "Vibe Checks" for their projects.
+- **Implementation**: Extended `RulesEngine` to load rules from `.openaudit/custom_rules.yaml` and `~/.openaudit/custom_rules.yaml`.
+- **CLI Commands**: `openaudit custom-rules init`, `openaudit custom-rules list`.
+- **Integration**: All scanners now support custom rules (SecretScanner, TechDebtScanner, etc.).
+
 ## 🛠️ Known Technical Debt & TODOs
 
 ### 1. Windows Encoding Support (FIXED)
@@ -63,4 +69,4 @@
 ## 🔮 Future Roadmap
 - [ ] **IDE Extensions**: VSCode extension using the MCP server.
 - [x] **Git Hooks**: Pre-commit hook added (`.pre-commit-config.yaml`).
-- [ ] **Custom Rules**: Allow users to define custom "Vibe Checks" (rules).
+- [x] **Custom Rules**: Implemented! Users can define custom rules via YAML files.

openaudit/core/rules_engine.py

@@ -1,16 +1,42 @@
 import yaml
 import re
+import os
 from pathlib import Path
-from typing import List
+from typing import List, Optional
 from .domain import Rule
 
 class RulesEngine:
-    def __init__(self, rules_path: str):
+    def __init__(self, rules_path: str, custom_rules_path: Optional[str] = None):
         self.rules_path = Path(rules_path)
+        self.custom_rules_path = custom_rules_path
 
     def load_rules(self) -> List[Rule]:
         rules = []
-        path_obj = self.rules_path
+        
+        # Load built-in rules
+        rules.extend(self._load_rules_from_path(self.rules_path))
+        
+        # Load custom rules from project directory
+        project_custom_rules = Path.cwd() / ".openaudit" / "custom_rules.yaml"
+        if project_custom_rules.exists():
+            rules.extend(self._load_rules_from_path(project_custom_rules))
+        
+        # Load custom rules from home directory
+        home_custom_rules = Path.home() / ".openaudit" / "custom_rules.yaml"
+        if home_custom_rules.exists():
+            rules.extend(self._load_rules_from_path(home_custom_rules))
+        
+        # Load custom rules from provided path
+        if self.custom_rules_path:
+            custom_path = Path(self.custom_rules_path)
+            if custom_path.exists():
+                rules.extend(self._load_rules_from_path(custom_path))
+        
+        return rules
+    
+    def _load_rules_from_path(self, path: Path) -> List[Rule]:
+        rules = []
+        path_obj = Path(path)
 
         if not path_obj.exists():
             return rules
@@ -60,5 +86,3 @@ def load_rules(self) -> List[Rule]:
                 print(f"Error loading rules from {file_path}: {e}")
 
         return rules
-            
-        return rules

openaudit/features/debt/scanner.py

@@ -2,15 +2,17 @@
 import re
 import os
 from pathlib import Path
-from openaudit.core.domain import Finding, Severity, Confidence, ScanContext
+from openaudit.core.domain import Finding, Severity, Confidence, ScanContext, Rule
 from openaudit.core.interfaces import ScannerProtocol
 
 class TechDebtScanner(ScannerProtocol):
     """
     Scans for technical debt, leftovers, and temporary code ("Vibe Checks").
+    Now supports both built-in patterns and custom rules.
     """
 
-    def __init__(self, rules: Dict = None):
+    def __init__(self, rules: List[Rule] = None):
+        # Built-in patterns (backward compatibility)
         self.patterns = {
             "ANNOTATION": {
                 "pattern": re.compile(r"(TODO|FIXME|HACK|XXX|BUG):\s*(.*)", re.IGNORECASE),
@@ -33,6 +35,23 @@ def __init__(self, rules: Dict = None):
                 "desc": "Hardcoded IP address"
             }
         }
+        
+        # Custom rules from YAML
+        self.custom_rules = []
+        if rules:
+            # Filter for technical_debt category rules
+            self.custom_rules = [r for r in rules if r.category in ["technical_debt", "security", "general"]]
+            self._compile_custom_rules()
+    
+    def _compile_custom_rules(self):
+        """Compile regex patterns for custom rules."""
+        self.compiled_custom_rules = []
+        for rule in self.custom_rules:
+            try:
+                self.compiled_custom_rules.append((rule, re.compile(rule.regex)))
+            except re.error as e:
+                print(f"Warning: Failed to compile regex for rule {rule.id}: {e}")
+                pass
 
     def _iterate_files(self, context: ScanContext):
         target = Path(context.target_path)
@@ -79,7 +98,7 @@ def scan_content(self, content: str, file_path: str) -> List[Finding]:
         findings = []
         lines = content.splitlines()
 
-        # Line-by-line scanning
+        # Scan with built-in patterns
         for i, line in enumerate(lines, 1):
             for key, rule in self.patterns.items():
                 match = rule["pattern"].search(line)
@@ -103,6 +122,28 @@ def scan_content(self, content: str, file_path: str) -> List[Finding]:
                         category="technical_debt",
                         remediation="Review and clean up code."
                     ))
+        
+        # Scan with custom rules
+        for rule, regex in self.compiled_custom_rules:
+            for line_num, line in enumerate(lines, 1):
+                for match in regex.finditer(line):
+                    # Skip if ignore comment is present
+                    if "noqa" in line or "@ignore" in line:
+                        continue
+                    
+                    matched_text = match.group(0).strip()[:50]
+                    findings.append(Finding(
+                        rule_id=rule.id,
+                        description=rule.description,
+                        file_path=file_path,
+                        line_number=line_num,
+                        secret_hash=matched_text,
+                        severity=rule.severity,
+                        confidence=rule.confidence,
+                        category=rule.category,
+                        remediation=rule.remediation
+                    ))
+        
         return findings
 
         return findings

openaudit/interface/cli/app.py

@@ -1,5 +1,5 @@
 import typer
-from .commands import scan_command, explain_command, config_app, mcp_command
+from .commands import scan_command, explain_command, config_app, mcp_command, custom_rules_app
 
 app = typer.Typer(
     name="OpenAuditKit",
@@ -18,4 +18,5 @@ def main_callback():
 app.command(name="explain")(explain_command)
 app.command(name="mcp")(mcp_command)
 app.add_typer(config_app, name="config")
+app.add_typer(custom_rules_app, name="custom-rules")
 

openaudit/interface/cli/commands.py

@@ -26,6 +26,87 @@
 from openaudit.features.explain.agent import ExplainAgent
 from openaudit.interface.cli.ui import UI
 from openaudit.features.debt.scanner import TechDebtScanner
+import shutil
+
+# Custom Rules Sub-app
+custom_rules_app = typer.Typer(name="custom-rules", help="Manage custom rules")
+
+@custom_rules_app.command(name="init")
+def custom_rules_init(
+    location: str = typer.Option("project", help="Where to create custom_rules.yaml: 'project' or 'home'")
+):
+    """
+    Initialize a custom_rules.yaml template.
+    """
+    if location == "home":
+        target_dir = Path.home() / ".openaudit"
+        target_file = target_dir / "custom_rules.yaml"
+    else:
+        target_dir = Path.cwd() / ".openaudit"
+        target_file = target_dir / "custom_rules.yaml"
+    
+    if target_file.exists():
+        UI.warning(f"Custom rules file already exists at: {target_file}")
+        overwrite = typer.confirm("Do you want to overwrite it?", default=False)
+        if not overwrite:
+            UI.info("Aborting.")
+            raise typer.Exit(code=0)
+    
+    # Create directory if needed
+    target_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Copy template
+    import openaudit
+    package_dir = Path(openaudit.__file__).parent.parent
+    template_file = package_dir / ".openaudit" / "custom_rules.yaml"
+    
+    if template_file.exists():
+        shutil.copy(template_file, target_file)
+        UI.success(f"Custom rules template created at: {target_file}")
+        UI.info("Edit this file to add your own rules, then run 'openaudit scan' to use them.")
+    else:
+        # Create a basic template inline if not found
+        template_content = """# OpenAuditKit Custom Rules
+# Add your custom rules here
+
+rules:
+  - id: "CUSTOM_EXAMPLE"
+    description: "Example custom rule"
+    regex: "CHANGEME_[A-Z0-9]+"
+    severity: "high"
+    confidence: "high"
+    category: "secret"
+    remediation: "Replace with actual rule pattern."
+"""
+        target_file.write_text(template_content, encoding='utf-8')
+        UI.success(f"Custom rules template created at: {target_file}")
+        UI.info("Edit this file to add your own rules.")
+
+@custom_rules_app.command(name="list")
+def custom_rules_list():
+    """
+    List all active custom rules locations.
+    """
+    locations = []
+    
+    project_custom = Path.cwd() / ".openaudit" / "custom_rules.yaml"
+    if project_custom.exists():
+        locations.append(("Project", str(project_custom)))
+    
+    home_custom = Path.home() / ".openaudit" / "custom_rules.yaml"
+    if home_custom.exists():
+        locations.append(("Home", str(home_custom)))
+    
+    if not locations:
+        UI.info("No custom rules files found.")
+        UI.info("Run 'openaudit custom-rules init' to create one.")
+    else:
+        UI.success("Active custom rules locations:")
+        for label, path in locations:
+            UI.info(f"  [{label}] {path}")
+
+
+
 
 
 class OutputFormat(str, Enum):
@@ -92,7 +173,7 @@ def scan_command(
     scanners = [
         SecretScanner(rules=rules),
         ConfigScanner(rules=rules),
-        TechDebtScanner()
+        TechDebtScanner(rules=rules)  # Now supports custom rules
     ]
 
     # 4. Run Scan

openaudit/mcp/server.py

@@ -45,7 +45,7 @@ def scan_workspace(path: str, checks: List[str] = ["secrets", "config", "debt"])
     if "config" in checks:
         scanners.append(ConfigScanner(rules=rules))
     if "debt" in checks:
-        scanners.append(TechDebtScanner())
+        scanners.append(TechDebtScanner(rules=rules))
 
     all_findings = []
     for scanner in scanners:
@@ -81,7 +81,7 @@ def check_file(file_path: str, content: str = None) -> str:
 
     # Initialize scanners
     secret_scanner = SecretScanner(rules=rules)
-    debt_scanner = TechDebtScanner()
+    debt_scanner = TechDebtScanner(rules=rules)
 
     file_content = content