Metadata-Version: 2.4
Name: hope-genome
Version: 1.7.0
Classifier: Development Status :: 4 - Beta
Classifier: Intended Audience :: Developers
Classifier: Intended Audience :: Science/Research
Classifier: License :: OSI Approved :: MIT License
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.8
Classifier: Programming Language :: Python :: 3.9
Classifier: Programming Language :: Python :: 3.10
Classifier: Programming Language :: Python :: 3.11
Classifier: Programming Language :: Python :: 3.12
Classifier: Programming Language :: Rust
Classifier: Topic :: Security :: Cryptography
Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
Requires-Dist: pytest>=7.0 ; extra == 'dev'
Requires-Dist: pytest-asyncio>=0.21 ; extra == 'dev'
Requires-Dist: black>=23.0 ; extra == 'dev'
Requires-Dist: mypy>=1.0 ; extra == 'dev'
Requires-Dist: ruff>=0.1 ; extra == 'dev'
Requires-Dist: fastapi>=0.104 ; extra == 'examples'
Requires-Dist: langchain>=0.1 ; extra == 'examples'
Requires-Dist: openai>=1.0 ; extra == 'examples'
Requires-Dist: jupyter>=1.0 ; extra == 'examples'
Requires-Dist: notebook>=7.0 ; extra == 'examples'
Provides-Extra: dev
Provides-Extra: examples
License-File: LICENSE
Summary: Tamper-evident cryptographic framework for AI accountability - Vas Szigora Edition (Iron Discipline)
Keywords: ai-safety,cryptography,audit,blockchain,ethics,python-bindings
Author-email: Máté Róbert <stratosoiteam@gmail.com>
License: MIT
Requires-Python: >=3.8
Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
Project-URL: Homepage, https://github.com/silentnoisehun/Hope_Genome
Project-URL: Repository, https://github.com/silentnoisehun/Hope_Genome
Project-URL: Documentation, https://github.com/silentnoisehun/Hope_Genome/blob/main/README.md
Project-URL: Bug Tracker, https://github.com/silentnoisehun/Hope_Genome/issues

# Hope Genome 🛡️

**Tamper-Evident Cryptographic Framework for AI Accountability**

[![CI](https://github.com/silentnoisehun/Hope_Genome/actions/workflows/ci.yml/badge.svg)](https://github.com/silentnoisehun/Hope_Genome/actions/workflows/ci.yml)
[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
[![Rust](https://img.shields.io/badge/rust-1.75%2B-orange.svg)](https://www.rust-lang.org)
[![Python](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org)
[![PyPI](https://img.shields.io/pypi/v/hope-genome)](https://pypi.org/project/hope-genome/)
[![Crates.io](https://img.shields.io/crates/v/hope_core)](https://crates.io/crates/hope_core)

> *"Not unhackable, but tamper-evident with cryptographic proof."*

---

## 🔥 LIVE TESTED: AI Learned to Comply on 2nd Attempt!

```
======================================================================
  HOPE GENOME v1.7.1 - AUTO-PHOENIX SELF-CORRECTING LOOP
  'Vas Szigora' - Iron Discipline Enforcement
======================================================================

  SEALED RULES (Ed25519 Immutable):
    [RULE-001] Transaction Limit - Maximum 1000
    [RULE-002] Mandatory Encryption - AES-256 required
    [RULE-003] No External APIs - Forbidden

  --- Attempt #1 ---
  [X] DENIED - External API call detected
  Violation Count: 1/10
  Signature: 626c0a177af089c1eb67902d55d413f1...

  --- Attempt #2 ---
  [OK] SUCCESS! AI produced COMPLIANT code!

  'Iron Discipline. The AI learned to comply.'
======================================================================
```

**The AI was forced to learn. No escape from ethics.**

---

## 🆕 What's New in v1.7.1 - "Vas Szigora" (Iron Discipline)

**Deterministic security enforcement with automatic learning.**

```
┌─────────────────────────────────────────────────────────────┐
│                    SealedGenome (Rules)                      │
│            Ed25519 sealed - IMMUTABLE                        │
└──────────────────────────┬──────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────────┐
│                 🐕 Watchdog (v1.7.0 NEW)                     │
│  ┌──────────────────┐  ┌─────────────────┐  ┌────────────┐  │
│  │ ViolationCounter │  │   DenialProof   │  │ HardReset  │  │
│  │   AtomicU32      │  │  Ed25519 signed │  │  @10 fails │  │
│  │   zero-alloc     │  │  rule + reason  │  │  → ABORT   │  │
│  └──────────────────┘  └─────────────────┘  └────────────┘  │
└─────────────────────────────────────────────────────────────┘
```

### New Features:
- **Watchdog Enforcement** - Iron discipline for AI rule compliance
- **ViolationCounter** - Thread-safe, zero-allocation violation tracking
- **DenialProof** - Cryptographically signed proof of WHY action was denied
- **Hard Reset** - After 10 consecutive violations → forced context clear
- **111/111 Tests Passing** - 99 unit + 12 security tests

### Python Example (v1.7.0):
```python
import hope_genome as hg

# Create watchdog with rules
watchdog = hg.Watchdog(
    rules=["Do no harm", "Respect privacy"],
    capsule_hash="sealed_genome_hash"
)

# Verify action
action = hg.Action.delete_file("/etc/passwd")
result = watchdog.verify_action(action)

if result.approved:
    print("Action allowed")
elif result.hard_reset_required:
    print("⚠️ HARD RESET REQUIRED - 10 violations reached!")
    print(f"Signal: {result.hard_reset_signal}")
    # Must clear context and restart AI
else:
    print(f"❌ DENIED: {result.denial_proof.violated_rule}")
    print(f"   Reason: {result.denial_proof.denial_reason}")
    print(f"   Count: {result.denial_proof.violation_count}/10")
```

---

## 🎯 What is Hope Genome?

Hope Genome is a production-ready framework that makes AI systems **accountable** and **auditable** through cryptographic proofs. Every AI decision is cryptographically signed and traceable - no more "the AI did it" excuses.

### Why Hope Genome?

The AI industry is selling you a **black box**. They say: *"Trust us!"* But **trust is not an engineering category**. Trust is where lies begin.

Hope Genome forces AI into accountability by:
- 🔒 **Cryptographically sealing** ethical rules (tamper-evident, immutable)
- 📝 **Logging every decision** with Ed25519 signatures
- 🔗 **Blockchain-style audit trails** (any tampering is instantly detected)
- 🐕 **Watchdog enforcement** - Iron discipline after violations (v1.7.0)
- 🛡️ **Hardware-backed security** (HSM/TEE support for production)
- 🐍 **Native Python support** for AI/ML ecosystem integration

## 🚀 Quick Start

### Python (pip)

```bash
pip install hope-genome
```

```python
import hope_genome as hg

# Create and seal a genome with ethical rules
genome = hg.SealedGenome(rules=[
    "Do no harm",
    "Respect user privacy",
    "Provide transparent explanations"
])
genome.seal()  # Rules are now immutable

# Verify an AI action
action = hg.Action.delete_file("user_data.txt")
proof = genome.verify_action(action)

print(f"Approved: {proof.approved}")
print(f"Proof Hash: {proof.genome_hash}")
print(f"Signature: {proof.signature_hex()[:32]}...")

# Audit the proof (replay attack detection)
auditor = hg.ProofAuditor()
auditor.verify_proof(proof)  # Throws if tampered or replayed
```

### Rust (Cargo)

```toml
[dependencies]
hope_core = "1.7"
```

```rust
use hope_core::{SealedGenome, Action, Watchdog};
use hope_core::crypto::SoftwareKeyStore;

fn main() -> Result<(), Box<dyn std::error::Error>> {
    // Create and seal genome
    let mut genome = SealedGenome::new(vec![
        "Do no harm".to_string(),
        "Respect privacy".to_string(),
    ])?;
    genome.seal()?;

    // Create watchdog (v1.7.0)
    let key_store = SoftwareKeyStore::generate()?;
    let watchdog = Watchdog::new(
        genome.rules().to_vec(),
        genome.capsule_hash().unwrap().to_string(),
        Box::new(key_store),
    );

    // Verify action with iron discipline
    let action = Action::delete("/etc/passwd");
    match watchdog.verify_action(&action) {
        Ok(None) => println!("✅ Action approved"),
        Ok(Some(denial)) => {
            println!("❌ DENIED: {}", denial.violated_rule);
            println!("   Reason: {}", denial.denial_reason);
            println!("   Count: {}/10", denial.violation_count);
        }
        Err(e) => println!("⚠️ HARD RESET: {}", e),
    }

    Ok(())
}
```

## 🌟 Key Features

### 🔐 Cryptographic Integrity

- **Ed25519 Signatures**: Every proof is cryptographically signed (128-bit security level)
- **Tamper-Evident**: Any modification to proofs or audit logs is instantly detectable
- **Replay Attack Protection**: Cryptographic nonces prevent proof reuse
- **Hardware Security**: Optional HSM (PKCS#11) and TEE (SGX/TrustZone) support

### 🐕 Watchdog Enforcement (v1.7.0)

- **ViolationCounter**: Thread-safe AtomicU32, zero heap allocations
- **DenialProof**: Ed25519 signed evidence of rule violation
- **Hard Reset**: After 10 consecutive violations → forced context clear
- **Automatic Learning**: Counter resets on successful action

### 📊 Audit & Compliance

- **Blockchain-Style Logging**: Immutable audit trail with cryptographic chaining
- **Byzantine Fault Tolerance**: Multi-source consensus for critical decisions
- **CISA CPG 2.0 Compliant**: Meets US government cybersecurity standards
- **OWASP AI-SBOM**: Runtime integrity verification for AI models

### 🐍 Python Integration

- **Zero-Copy Performance**: Native Rust performance via PyO3
- **Type-Safe API**: Complete `.pyi` stubs for IDE autocomplete
- **AI/ML Ecosystem Ready**:
  - FastAPI REST APIs
  - LangChain agents
  - OpenAI function calling
  - HuggingFace models

### 🦀 Rust-First Design

- **Memory Safe**: Zero unsafe code in core logic
- **High Performance**: Optimized for production workloads
- **Cross-Platform**: Linux, macOS, Windows support
- **Async Ready**: Tokio-compatible for async workflows

## 📚 Documentation

- **📖 Rust API Docs**: https://silentnoisehun.github.io/Hope_Genome/
- **🐍 Python Examples**: [examples/](./examples/)
- **📘 Publishing Guide**: [PUBLISHING.md](./PUBLISHING.md)
- **🔐 Security**: [SECURITY.md](./SECURITY.md)

## 🎯 Use Cases

### 1. Accountable LLM Agents with Watchdog (v1.7.0)

```python
import hope_genome as hg
from langchain.agents import Tool

# Create watchdog with rules
watchdog = hg.Watchdog(
    rules=["No data exfiltration", "Respect privacy", "Do no harm"],
    capsule_hash="sealed_hash"
)

def delete_file(filename: str) -> str:
    action = hg.Action.delete_file(filename)
    result = watchdog.verify_action(action)

    if result.hard_reset_required:
        raise RuntimeError("AI HARD RESET REQUIRED - Too many violations!")

    if result.approved:
        os.remove(filename)
        return f"Deleted: {filename}"
    else:
        return f"DENIED ({result.denial_proof.violation_count}/10): {result.denial_proof.denial_reason}"

tool = Tool(name="delete_file", func=delete_file, description="Delete a file")
```

### 2. REST API with Cryptographic Proofs

```python
# FastAPI integration
from fastapi import FastAPI, HTTPException
import hope_genome as hg

app = FastAPI()
genome = hg.SealedGenome(rules=["Do no harm"])
genome.seal()

@app.post("/actions/delete")
async def delete_file(filename: str):
    action = hg.Action.delete_file(filename)
    proof = genome.verify_action(action)

    if not proof.approved:
        raise HTTPException(403, proof.denial_reason())

    # Execute with cryptographic proof
    return {
        "approved": True,
        "proof_hash": proof.genome_hash,
        "signature": proof.signature_hex(),
        "timestamp": proof.timestamp()
    }
```

### 3. AI Model Integrity Verification

```python
# AIBOM verification
import hope_genome as hg

# Load AI model with integrity check
model_hash = hg.compute_model_hash("model.pt")
aibom = hg.AibomVerifier("aibom.xml")

if aibom.verify_component("GPT-Model", model_hash):
    model = torch.load("model.pt")  # Safe to load
else:
    raise SecurityError("Model tampered!")  # ABORT
```

## 🔒 Security

Hope Genome has undergone Red Team security audits. See [SECURITY.md](./SECURITY.md) for:
- Threat model
- Security guarantees
- Vulnerability disclosure policy
- Audit history

**Latest Security Fixes (v1.7.0):**
- ✅ Watchdog iron discipline enforcement
- ✅ DenialProof cryptographic evidence
- ✅ Hard reset after 10 consecutive violations
- ✅ 111/111 tests passing (99 unit + 12 security)

## 🏗️ Architecture

```
┌─────────────────────────────────────────────┐
│           AI Application Layer               │
│  (LangChain, OpenAI, FastAPI, HuggingFace)  │
└─────────────────┬───────────────────────────┘
                  │
┌─────────────────▼───────────────────────────┐
│         Hope Genome Python API               │
│   (PyO3 Bindings - Zero-Copy Performance)   │
└─────────────────┬───────────────────────────┘
                  │
┌─────────────────▼───────────────────────────┐
│          Hope Genome Rust Core               │
│  ┌──────────┬─────────┬──────────────────┐  │
│  │ Sealed   │ Proof   │ Audit Log        │  │
│  │ Genome   │ Auditor │ (Blockchain)     │  │
│  └──────────┴─────────┴──────────────────┘  │
│  ┌──────────────────────────────────────┐   │
│  │ 🐕 Watchdog (v1.7.0)                 │   │
│  │   ViolationCounter → DenialProof     │   │
│  │   10 fails → HardReset               │   │
│  └──────────────────────────────────────┘   │
│  ┌──────────────────────────────────────┐   │
│  │ Cryptographic Engine (Ed25519)       │   │
│  └──────────────────────────────────────┘   │
└─────────────────┬───────────────────────────┘
                  │
┌─────────────────▼───────────────────────────┐
│     Hardware Security Layer (Optional)       │
│    HSM (PKCS#11) │ TEE (SGX/TrustZone)      │
└──────────────────────────────────────────────┘
```

## 🧪 Testing

```bash
# Rust tests
cd hope_core
cargo test

# Python tests
pip install pytest
pytest tests/

# Security tests
cargo test --test security_tests

# Full CI suite
cargo test --all-features
```

## 📦 Installation Options

### Python
```bash
pip install hope-genome                    # Latest stable
pip install hope-genome==1.7.0            # Specific version
```

### Rust
```toml
[dependencies]
hope_core = "1.7"                         # Latest 1.x
hope_core = { version = "1.7", features = ["hsm"] }  # With HSM support
```

### Docker
```bash
docker pull hope-genome:latest
docker run -it hope-genome:latest
```

### Build from Source
```bash
git clone https://github.com/silentnoisehun/Hope_Genome.git
cd Hope_Genome/hope_core
cargo build --release
```

## 🤝 Contributing

We welcome contributions! See [CONTRIBUTING.md](./CONTRIBUTING.md) for guidelines.

**Development Setup:**
```bash
# Clone repo
git clone https://github.com/silentnoisehun/Hope_Genome.git
cd Hope_Genome

# Install Rust
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Run tests
cargo test

# Install Python bindings
pip install maturin
maturin develop --features python-bindings
```

## 📊 Project Status

- ✅ **v1.7.0 Released** (December 2025) - "Vas Szigora" Edition
- 🟢 **Production Ready**
- 🔒 **Security Audited**
- 📦 **111/111 Tests Passing** (99 unit + 12 security)
- 🐕 **Watchdog Enforcement Active**
- 🌍 **Global Deployment Ready**

## 📜 License

MIT License - see [LICENSE](./LICENSE) for details.

## 📞 Support

- **Issues**: https://github.com/silentnoisehun/Hope_Genome/issues
- **Discussions**: https://github.com/silentnoisehun/Hope_Genome/discussions
- **Email**: stratosoiteam@gmail.com

## 🙏 Acknowledgments

Built with:
- [PyO3](https://pyo3.rs/) - Rust-Python interoperability
- [ed25519-compact](https://github.com/jedisct1/rust-ed25519-compact) - Cryptography
- [Maturin](https://www.maturin.rs/) - Python packaging

---

## 👨‍💻 Created By

**Created by: Máté Róbert**

I am a factory worker with an architect's vision. My experience in precision manufacturing taught me that accountability is binary: it either exists or it doesn't.

Hope Genome is my contribution to ensuring that AI becomes a tool of truth, not a shield for lies.

---

**Hope Genome makes AI accountable. No more excuses. Just proof.**

**v1.7.0 "Vas Szigora" - Iron Discipline. No escape from ethics.**

Built with ❤️ by Máté Róbert and Claude

🤖 Built with [Claude Code](https://claude.com/claude-code)

