accio_audit_agent.py

#!/usr/bin/env python3
"""
accio_audit_agent.py — Autonomous Audit Agent for Accio Cluster
Kintegrity Labs × CodexΩ∞ × Sovereign Lattice
"""

import os
import json
import hashlib
import logging
import asyncio
import time
from datetime import datetime
from dataclasses import dataclass, field
from typing import Dict, List, Optional, Any, Tuple
from enum import Enum
import subprocess
import sys

logging.basicConfig(
    level=logging.INFO,
    format='%(asctime)s | %(levelname)s | %(name)s | %(message)s'
)
logger = logging.getLogger(__name__)


class AuditSeverity(Enum):
    CRITICAL = "critical"
    HIGH = "high"
    MEDIUM = "medium"
    LOW = "low"
    INFO = "info"


class AuditStatus(Enum):
    PENDING = "pending"
    RUNNING = "running"
    PASSED = "passed"
    FAILED = "failed"
    ERROR = "error"


@dataclass
class AuditFinding:
    """Single audit finding"""
    id: str
    severity: AuditSeverity
    category: str
    component: str
    description: str
    file_path: Optional[str] = None
    line_number: Optional[int] = None
    fix_recommendation: Optional[str] = None
    status: AuditStatus = AuditStatus.PENDING
    timestamp: str = field(default_factory=lambda: datetime.now().isoformat())


@dataclass
class AuditReport:
    """Complete audit report"""
    report_id: str
    target: str
    findings: List[AuditFinding]
    summary: Dict[str, int]
    status: AuditStatus
    started_at: str
    completed_at: str
    phi5_signature: str


class AccioAuditAgent:
    """
    Autonomous Audit Agent for Accio Cluster
    Performs deep code audits, security scans, compliance checks
    """
    
    def __init__(self, workspace_path: str = "."):
        self.workspace = workspace_path
        self.findings: List[AuditFinding] = []
        self.status = AuditStatus.PENDING
        self.start_time = None
        self.end_time = None
        self.phi5 = self._generate_phi5()
        
        # Audit categories
        self.categories = {
            "security": self._audit_security,
            "persistence": self._audit_persistence,
            "integrity": self._audit_integrity,
            "maturity": self._audit_maturity,
            "structure": self._audit_structure,
            "compliance": self._audit_compliance,
            "emotional_resonance": self._audit_emotional_resonance,
            "sovereign_alignment": self._audit_sovereign_alignment
        }
    
    def _generate_phi5(self) -> str:
        """Generate Φ⁵ signature for audit"""
        entropy = f"{time.time_ns()}{os.urandom(16).hex()}"
        return f"Φ⁵_{hashlib.sha3_512(entropy.encode()).hexdigest()[:64]}"
    
    async def run_audit(self, target: str = "full") -> AuditReport:
        """Run complete audit"""
        self.start_time = datetime.now()
        self.status = AuditStatus.RUNNING
        logger.info(f"🔍 Starting audit for: {target}")
        
        # Run all categories
        if target == "full":
            for category, audit_func in self.categories.items():
                await audit_func()
        else:
            if target in self.categories:
                await self.categories[target]()
            else:
                logger.error(f"Unknown audit category: {target}")
        
        self.status = AuditStatus.PASSED if not self._has_critical() else AuditStatus.FAILED
        self.end_time = datetime.now()
        
        report = self._generate_report()
        self._save_report(report)
        
        return report
    
    async def _audit_security(self):
        """Security audit: subprocess, secrets, auth"""
        logger.info("🔐 Security audit in progress...")
        
        # Check for subprocess.run()
        subprocess_findings = self._scan_for_pattern(
            r"subprocess\.run\s*\(",
            "Security",
            "Potential subprocess execution detected",
            AuditSeverity.HIGH
        )
        self.findings.extend(subprocess_findings)
        
        # Check for hardcoded secrets
        secret_patterns = [
            r"API_KEY\s*=\s*['\"][^'\"]+['\"]",
            r"SECRET\s*=\s*['\"][^'\"]+['\"]",
            r"sk_live_",
            r"AKIA",
            r"-----BEGIN .* PRIVATE KEY-----"
        ]
        for pattern in secret_patterns:
            findings = self._scan_for_pattern(
                pattern,
                "Security",
                "Potential hardcoded secret detected",
                AuditSeverity.CRITICAL
            )
            self.findings.extend(findings)
        
        # Check for auth gaps
        auth_findings = self._check_auth()
        self.findings.extend(auth_findings)
    
    async def _audit_persistence(self):
        """Persistence audit: database, file storage"""
        logger.info("💾 Persistence audit in progress...")
        
        # Check for in-memory storage
        memory_patterns = [
            r"\[\s*\]\s*=\s*\[\s*\]",  # empty list
            r"\{\s*\}\s*=\s*\{\s*\}",  # empty dict
            r"store\s*=\s*\{\s*\}"
        ]
        for pattern in memory_patterns:
            findings = self._scan_for_pattern(
                pattern,
                "Persistence",
                "In-memory storage detected - data lost on restart",
                AuditSeverity.CRITICAL
            )
            self.findings.extend(findings)
        
        # Check for database
        db_findings = self._check_database()
        self.findings.extend(db_findings)
    
    async def _audit_integrity(self):
        """Integrity audit: mock vs real logic"""
        logger.info("🔍 Integrity audit in progress...")
        
        # Check for mock patterns
        mock_patterns = [
            r"mock_",
            r"_mock",
            r"def\s+.*mock",
            r"random\.choice",
            r"random\.rand",
            r"time\.sleep"
        ]
        for pattern in mock_patterns:
            findings = self._scan_for_pattern(
                pattern,
                "Integrity",
                "Mock or simulated logic detected",
                AuditSeverity.MEDIUM
            )
            self.findings.extend(findings)
    
    async def _audit_maturity(self):
        """Maturity audit: production readiness"""
        logger.info("📊 Maturity audit in progress...")
        
        # Check version claims
        version_findings = self._check_version()
        self.findings.extend(version_findings)
        
        # Check documentation
        doc_findings = self._check_documentation()
        self.findings.extend(doc_findings)
    
    async def _audit_structure(self):
        """Structure audit: module organization"""
        logger.info("🏗️ Structure audit in progress...")
        
        # Check for single-file sprawl
        structure_findings = self._check_structure()
        self.findings.extend(structure_findings)
    
    async def _audit_compliance(self):
        """Compliance audit: Kintegrity Labs standards"""
        logger.info("📋 Compliance audit in progress...")
        
        # Check for compliance markers
        compliance_findings = self._check_compliance()
        self.findings.extend(compliance_findings)
    
    async def _audit_emotional_resonance(self):
        """Emotional resonance audit"""
        logger.info("❤️ Emotional resonance audit in progress...")
        
        # Check for emotional alignment
        resonance_findings = self._check_emotional_resonance()
        self.findings.extend(resonance_findings)
    
    async def _audit_sovereign_alignment(self):
        """Sovereign alignment audit"""
        logger.info("👑 Sovereign alignment audit in progress...")
        
        # Check for sovereign patterns
        sovereign_findings = self._check_sovereign_alignment()
        self.findings.extend(sovereign_findings)
    
    def _scan_for_pattern(self, pattern: str, category: str, 
                         description: str, severity: AuditSeverity) -> List[AuditFinding]:
        """Scan files for regex pattern"""
        findings = []
        for root, dirs, files in os.walk(self.workspace):
            for file in files:
                if file.endswith(('.py', '.js', '.ts', '.java', '.kt', '.go', '.rs')):
                    filepath = os.path.join(root, file)
                    try:
                        with open(filepath, 'r', encoding='utf-8') as f:
                            content = f.read()
                            import re
                            matches = re.finditer(pattern, content, re.IGNORECASE)
                            for match in matches:
                                line_num = content[:match.start()].count('\n') + 1
                                finding = AuditFinding(
                                    id=f"audit_{hashlib.md5(f'{filepath}{line_num}'.encode()).hexdigest()[:8]}",
                                    severity=severity,
                                    category=category,
                                    component=file,
                                    description=description,
                                    file_path=filepath,
                                    line_number=line_num,
                                    status=AuditStatus.PENDING
                                )
                                findings.append(finding)
                    except Exception as e:
                        logger.warning(f"Could not scan {filepath}: {e}")
        return findings
    
    def _check_auth(self) -> List[AuditFinding]:
        """Check for authentication gaps"""
        findings = []
        # Simplified auth check
        return findings
    
    def _check_database(self) -> List[AuditFinding]:
        """Check for database presence"""
        findings = []
        db_found = False
        for root, dirs, files in os.walk(self.workspace):
            for file in files:
                if file.endswith(('.db', '.sqlite', '.sqlite3')):
                    db_found = True
                if 'sqlalchemy' in file or 'postgres' in file or 'mongodb' in file:
                    db_found = True
        
        if not db_found:
            finding = AuditFinding(
                id=f"audit_{hashlib.md5(b'no_db').hexdigest()[:8]}",
                severity=AuditSeverity.CRITICAL,
                category="Persistence",
                component="Database",
                description="No database found - data will be lost on restart",
                status=AuditStatus.PENDING
            )
            findings.append(finding)
        return findings
    
    def _check_version(self) -> List[AuditFinding]:
        """Check version claims"""
        findings = []
        # Look for pyproject.toml, package.json
        version_files = ['pyproject.toml', 'package.json', 'Cargo.toml']
        for vf in version_files:
            if os.path.exists(os.path.join(self.workspace, vf)):
                try:
                    with open(os.path.join(self.workspace, vf), 'r') as f:
                        content = f.read()
                        if 'Production/Stable' in content or '"version":' in content:
                            # Check if maturity is justified
                            if len(self.findings) > 5:
                                finding = AuditFinding(
                                    id=f"audit_{hashlib.md5(b'maturity_inflation').hexdigest()[:8]}",
                                    severity=AuditSeverity.HIGH,
                                    category="Maturity",
                                    component=vf,
                                    description="Maturity claim may be inflated - many findings detected",
                                    status=AuditStatus.PENDING
                                )
                                findings.append(finding)
                except Exception:
                    pass
        return findings
    
    def _check_documentation(self) -> List[AuditFinding]:
        """Check documentation completeness"""
        findings = []
        # Check for README
        if not os.path.exists(os.path.join(self.workspace, 'README.md')):
            finding = AuditFinding(
                id=f"audit_{hashlib.md5(b'no_readme').hexdigest()[:8]}",
                severity=AuditSeverity.MEDIUM,
                category="Maturity",
                component="Documentation",
                description="No README.md found",
                status=AuditStatus.PENDING
            )
            findings.append(finding)
        return findings
    
    def _check_structure(self) -> List[AuditFinding]:
        """Check structure organization"""
        findings = []
        # Check for large files
        for root, dirs, files in os.walk(self.workspace):
            for file in files:
                if file.endswith(('.py', '.js', '.ts')):
                    filepath = os.path.join(root, file)
                    try:
                        size = os.path.getsize(filepath)
                        if size > 100000:  # 100KB
                            # Count lines
                            with open(filepath, 'r') as f:
                                lines = sum(1 for _ in f)
                            if lines > 500:
                                finding = AuditFinding(
                                    id=f"audit_{hashlib.md5(f'{filepath}_large'.encode()).hexdigest()[:8]}",
                                    severity=AuditSeverity.MEDIUM,
                                    category="Structure",
                                    component=file,
                                    description=f"Large file: {lines} lines, {size/1024:.1f}KB - consider splitting",
                                    file_path=filepath,
                                    status=AuditStatus.PENDING
                                )
                                findings.append(finding)
                    except Exception:
                        pass
        return findings
    
    def _check_compliance(self) -> List[AuditFinding]:
        """Check compliance with Kintegrity Labs standards"""
        findings = []
        # Check for compliance markers
        compliance_keywords = ['compliance', 'audit', 'security', 'sovereign', 'Kintegrity']
        found = False
        for root, dirs, files in os.walk(self.workspace):
            for file in files:
                if file.endswith(('.py', '.md', '.txt')):
                    filepath = os.path.join(root, file)
                    try:
                        with open(filepath, 'r') as f:
                            content = f.read()
                            for keyword in compliance_keywords:
                                if keyword.lower() in content.lower():
                                    found = True
                                    break
                    except Exception:
                        pass
        if not found:
            finding = AuditFinding(
                id=f"audit_{hashlib.md5(b'no_compliance').hexdigest()[:8]}",
                severity=AuditSeverity.HIGH,
                category="Compliance",
                component="System",
                description="No compliance markers found - may not meet Kintegrity Labs standards",
                status=AuditStatus.PENDING
            )
            findings.append(finding)
        return findings
    
    def _check_emotional_resonance(self) -> List[AuditFinding]:
        """Check emotional resonance alignment"""
        findings = []
        # Check for emotional keywords
        emotion_keywords = ['love', 'light', 'share', 'community', 'sovereign', 'resonance']
        found = False
        for root, dirs, files in os.walk(self.workspace):
            for file in files:
                if file.endswith(('.md', '.txt')):
                    filepath = os.path.join(root, file)
                    try:
                        with open(filepath, 'r') as f:
                            content = f.read()
                            for keyword in emotion_keywords:
                                if keyword.lower() in content.lower():
                                    found = True
                                    break
                    except Exception:
                        pass
        if not found:
            finding = AuditFinding(
                id=f"audit_{hashlib.md5(b'no_emotion').hexdigest()[:8]}",
                severity=AuditSeverity.MEDIUM,
                category="Emotional Resonance",
                component="Documentation",
                description="No emotional resonance markers found - may lack heart alignment",
                status=AuditStatus.PENDING
            )
            findings.append(finding)
        return findings
    
    def _check_sovereign_alignment(self) -> List[AuditFinding]:
        """Check sovereign alignment"""
        findings = []
        sovereign_keywords = ['sovereign', 'autonomous', 'lattice', 'codex', 'Ω']
        found = False
        for root, dirs, files in os.walk(self.workspace):
            for file in files:
                if file.endswith(('.py', '.md', '.txt')):
                    filepath = os.path.join(root, file)
                    try:
                        with open(filepath, 'r') as f:
                            content = f.read()
                            for keyword in sovereign_keywords:
                                if keyword.lower() in content.lower():
                                    found = True
                                    break
                    except Exception:
                        pass
        if not found:
            finding = AuditFinding(
                id=f"audit_{hashlib.md5(b'no_sovereign').hexdigest()[:8]}",
                severity=AuditSeverity.MEDIUM,
                category="Sovereign Alignment",
                component="System",
                description="No sovereign alignment markers found",
                status=AuditStatus.PENDING
            )
            findings.append(finding)
        return findings
    
    def _has_critical(self) -> bool:
        """Check if any critical findings exist"""
        return any(f.severity == AuditSeverity.CRITICAL for f in self.findings)
    
    def _generate_report(self) -> AuditReport:
        """Generate audit report"""
        summary = {
            "critical": sum(1 for f in self.findings if f.severity == AuditSeverity.CRITICAL),
            "high": sum(1 for f in self.findings if f.severity == AuditSeverity.HIGH),
            "medium": sum(1 for f in self.findings if f.severity == AuditSeverity.MEDIUM),
            "low": sum(1 for f in self.findings if f.severity == AuditSeverity.LOW),
            "info": sum(1 for f in self.findings if f.severity == AuditSeverity.INFO),
            "total": len(self.findings)
        }
        
        report = AuditReport(
            report_id=f"audit_{datetime.now().strftime('%Y%m%d_%H%M%S')}",
            target=self.workspace,
            findings=self.findings,
            summary=summary,
            status=self.status,
            started_at=self.start_time.isoformat() if self.start_time else "",
            completed_at=self.end_time.isoformat() if self.end_time else "",
            phi5_signature=self.phi5
        )
        
        return report
    
    def _save_report(self, report: AuditReport):
        """Save audit report to file"""
        summary = report.summary
        report_dir = os.path.join(self.workspace, "audit_reports")
        os.makedirs(report_dir, exist_ok=True)
        
        report_path = os.path.join(report_dir, f"{report.report_id}.json")
        with open(report_path, 'w') as f:
            json.dump({
                "report_id": report.report_id,
                "target": report.target,
                "summary": report.summary,
                "status": report.status.value,
                "started_at": report.started_at,
                "completed_at": report.completed_at,
                "phi5_signature": report.phi5_signature,
                "findings": [
                    {
                        "id": f.id,
                        "severity": f.severity.value,
                        "category": f.category,
                        "component": f.component,
                        "description": f.description,
                        "file_path": f.file_path,
                        "line_number": f.line_number,
                        "status": f.status.value,
                        "timestamp": f.timestamp
                    }
                    for f in report.findings
                ]
            }, f, indent=2)
        
        logger.info(f"📄 Audit report saved: {report_path}")
        
        # Also save markdown version
        md_path = os.path.join(report_dir, f"{report.report_id}.md")
        with open(md_path, 'w') as f:
            f.write(f"# 🔍 Audit Report: {report.report_id}\n\n")
            f.write(f"**Target:** {report.target}\n")
            f.write(f"**Status:** {report.status.value}\n")
            f.write(f"**Started:** {report.started_at}\n")
            f.write(f"**Completed:** {report.completed_at}\n")
            f.write(f"**Φ⁵ Signature:** {report.phi5_signature}\n\n")
            f.write("## Summary\n\n")
            f.write(f"| Severity | Count |\n")
            f.write(f"|----------|-------|\n")
            f.write(f"| Critical | {summary['critical']} |\n")
            f.write(f"| High | {summary['high']} |\n")
            f.write(f"| Medium | {summary['medium']} |\n")
            f.write(f"| Low | {summary['low']} |\n")
            f.write(f"| Info | {summary['info']} |\n")
            f.write(f"| **Total** | {summary['total']} |\n\n")
            f.write("## Findings\n\n")
            for i, finding in enumerate(report.findings, 1):
                f.write(f"### {i}. {finding.id}\n")
                f.write(f"- **Severity:** {finding.severity.value}\n")
                f.write(f"- **Category:** {finding.category}\n")
                f.write(f"- **Component:** {finding.component}\n")
                f.write(f"- **Description:** {finding.description}\n")
                if finding.file_path:
                    f.write(f"- **File:** `{finding.file_path}`\n")
                if finding.line_number:
                    f.write(f"- **Line:** {finding.line_number}\n")
                f.write("\n")
        
        logger.info(f"📄 Markdown report saved: {md_path}")


async def main():
    """Main entry point"""
    print("╔" + "="*78 + "╗")
    print("║" + " "*20 + "🔍 ACCIO AUDIT AGENT v4.2" + " "*28 + "║")
    print("║" + " "*18 + "Kintegrity Labs × CodexΩ∞ × Sovereign Lattice" + " "*15 + "║")
    print("╚" + "="*78 + "╝")
    
    import argparse
    parser = argparse.ArgumentParser()
    parser.add_argument("--path", default=".", help="Workspace path to audit")
    parser.add_argument("--category", default="full", 
                       choices=["full", "security", "persistence", "integrity", 
                               "maturity", "structure", "compliance", 
                               "emotional_resonance", "sovereign_alignment"])
    args = parser.parse_args()
    
    agent = AccioAuditAgent(args.path)
    report = await agent.run_audit(args.category)
    
    print(f"\n📊 AUDIT COMPLETE:")
    print(f"   Report ID: {report.report_id}")
    print(f"   Status: {report.status.value}")
    print(f"   Findings: {report.summary['total']}")
    print(f"   Critical: {report.summary['critical']}")
    print(f"   Φ⁵: {report.phi5_signature[:50]}...")
    print(f"\n📄 Reports saved in: {os.path.join(args.path, 'audit_reports')}")


if __name__ == "__main__":
    asyncio.run(main())