madilang 0.5.1

Sovereign intent-driven programming language. Describe what you want, MadiLang generates secure, ethical, production-ready backends with cryptographic proof of origin. Mobile-first • Multi-target (Node.js + Python) • Zero-config diagnostics.

🧠 MadiLang v0.5.0

✨ Code is no longer written. It is described. ✨

MadiLang transforms human-readable intent into production-ready, secure, and sovereign backend systems. Describe what you want — MadiLang generates the rest with cryptographic proof of origin.

---

🚀 Quick Links

✨ Get Started • 📖 Wiki • 🩺 madi doctor • 🧬 Philosophy • 🤝 Contribute • 💬 Discussions

---

🌟 The Sovereign Difference

In a world of boilerplate, complexity, and hidden logic, MadiLang restores clarity, sovereignty, and trust.

Dimension	Traditional Development	MadiLang
🧠 Abstraction	Write implementation details	Describe intent
🔐 Provenance	Manual audit trails	Cryptographic signature in every artifact
🛡️ Security	Add as afterthought	Security & ethics by default
📱 Accessibility	Requires full IDE/PC	Mobile-first — develop on Termux/phone
⚡ Boilerplate	Repetitive setup code	Zero boilerplate — generated automatically
🔗 Extensibility	Modify core or fork	Plugin system — extend without touching core
🌐 Targets	Single language per project	Multi-target — Node.js + Python (FastAPI)
🩺 Diagnostics	Manual debugging	madi doctor — instant environment health check

💎 MadiLang is not just a tool. It's a declaration: Human intent is the sovereign layer.

---

🔥 Live Example: From Intent to Production API

📝 Describe Your Intent (auth.madi)

entity: User
fields:
  - name: string
  - email: string (unique)
  - password: string (secure)
  - createdAt: datetime (auto)

intent: register_user
route: "/api/signup"
method: POST
inputs: (name, email, password)

steps:
  find User by email as existing_user
  
  if existing_user:
    show error "Email already exists"
    stop process
  
  create User
  generate token
  return success with token

🚀 Generate & Run

madi run auth.madi --target nodejs    # Node.js + Express
madi run auth.madi --target python    # Python + FastAPI ← NEW in v0.5.0

📤 Output: Sovereign Backend

🟢 Node.js / Express Output

// ════════════════════════════════════════════════════════════════════
// 🔐 MadiLang Sovereign Intent Signature
// ════════════════════════════════════════════════════════════════════
const __MADI_SIGNATURE__ = {
  "developer": { "id": "madani004" },
  "intent": { "hash": "a3f8c2...", "fingerprint": "7d9e1b..." },
  "timestamp": { "iso": "2026-06-21T12:00:00Z" },
  "ethics": { "score": 0.95, "passed": true },
  "signature": { "algorithm": "SHA256-HMAC", "value": "..." }
};
// ════════════════════════════════════════════════════════════════════

app.post('/api/signup', validateInputs(['name','email','password']), async (req, res) => {
  const existing_user = await prisma.user.findUnique({ where: { email: req.body.email } });
  if (existing_user) return res.status(400).json({ error: "Email already exists" });
  
  const result = await prisma.user.create({
    data: { name: req.body.name, email: req.body.email, password: await bcrypt.hash(req.body.password, 10) }
  });
  
  const token = jwt.sign({ id: result.id }, process.env.JWT_SECRET, { expiresIn: '7d' });
  return res.status(200).json({ success: true, token });
});

🐍 Python / FastAPI Output ← NEW

# ════════════════════════════════════════════════════════════════════
# 🔐 MadiLang Sovereign Intent Signature
# ════════════════════════════════════════════════════════════════════
__MADI_SIGNATURE__ = {
    "developer": {"id": "madani004"},
    "intent": {"hash": "a3f8c2...", "fingerprint": "7d9e1b..."},
    "timestamp": {"iso": "2026-06-21T12:00:00Z"},
    "ethics": {"score": 0.95, "passed": True},
    "signature": {"algorithm": "SHA256-HMAC", "value": "..."}
}
# ════════════════════════════════════════════════════════════════════

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel

app = FastAPI(title="MadiLang Sovereign Backend")

class RegisterUserInput(BaseModel):
    name: str
    email: str
    password: str

@app.post("/api/signup")
async def register_user(data: RegisterUserInput):
    existing = await db.user.find(email=data.email)
    if existing:
        raise HTTPException(status_code=400, detail="Email already exists")
    
    result = await db.user.create(name=data.name, email=data.email, password=hash_password(data.password))
    token = generate_token(result["id"])
    return {"success": True, "token": token}

✅ Secure by default: Password hashing, input validation, error handling, JWT generation. 🔐 Sovereign by design: Every file carries a verifiable signature binding it to the original intent.

---

🆕 What's New in v0.5.0

🐍 Python/FastAPI Generator

Full support for generating async FastAPI backends with Pydantic models, automatic validation, and Uvicorn server setup. Same intent, new target.

🩺 madi doctor Command

Instant environment diagnostics checking Python, Node.js, npm, network connectivity, sovereign secrets, and write permissions. Works on Termux, desktop, and CI.

$ madi doctor
🖥️  SYSTEM ENVIRONMENT
  ✅ Python   v3.13.13      (/usr/bin/python3.13)
  ✅ Nodejs   v26.3.1       (/usr/bin/node)
  ✅ Npm      v11.16.0      (/usr/bin/npm)
  ✅ Write Access   /home/user/my-backend
  ℹ️ Platform      Android aarch64 📱 Mobile (Termux)

🔐 SOVEREIGN SECRETS
  ✅ SET     MADI_SIGNATURE_SECRET   [Sove****]
  ✅ SET     MADI_DEVELOPER_ID       [mada****]

🌐 NETWORK CONNECTIVITY
  ✅ npm_registry       https://registry.npmjs.org/
  ✅ pypi_index         https://pypi.org/simple/
  ✅ github_api         https://api.github.com/

✅ ALL CHECKS PASSED — Environment is sovereign-ready!

🛡️ Sovereign Hybrid Adapter

Generated code intelligently detects database availability. If Prisma/SQLAlchemy isn't configured, it falls back to a built-in mock adapter — ensuring the backend runs everywhere without configuration hell.

🏗️ Modular CLI Architecture

CLI refactored into independent command modules with lazy loading for faster startup on mobile devices.

---

📱 Mobile-First Sovereignty

MadiLang is designed to run anywhere Python runs — including your smartphone. No heavy IDE. No powerful PC. Just intent and sovereignty.

🤖 Termux Setup (Android)

# 1. Install dependencies
pkg update && pkg install python nodejs git

# 2. Clone repository
git clone https://github.com/madanimkhitar22-beep/madilang.git
cd madilang

# 3. Install in editable mode
pip install -e .

# 4. Verify installation
madi --version
# 🧠 MadiLang v0.5.0 — Sovereign Intent Compiler

# 5. Diagnose environment ← NEW
madi doctor

# 6. Initialize and run
madi init my-backend
cd my-backend
madi run src/main.madi --target python

🍎 iOS (via Pythonista or similar)

pip install madilang
madi doctor          # Verify environment
madi run your_file.madi

💡 Democratizing development: Build sovereign backends from anywhere, even a smartphone.

---

🏗️ Architecture v0.5.0

┌─────────────────────────────────────────────────────────────────────────────────┐
│                    🧠 MadiLang Sovereign Compiler Pipeline                                    │
├─────────────────────────────────────────────────────────────────────────────────┤
│                                                                                               │
│  📝 Source (.madi)                                                                            │
│       ↓                                                                                        │
│  🔍 Parser (Recursive Descent) → AST                                                         │
│       ↓                                                                                        │
│  📋 Analyzer (Semantic Validation + Ethics Enrichment)                                        │
│       ↓                                                                                        │
│  🔐 IntentSignature (Cryptographic Binding + Provenance)                                      │
│       ↓                                                                                        │
│  ⚙️ StepCompiler → IR (Language-Agnostic Intermediate Representation)                        │
│       ↓                                                                                        │
│  🧩 Plugin Hooks (Ethics, Security, Custom Transformers)                                      │
│       ↓                                                                                        │
│  🏗️ CodeGenerator → Target Code                                                              │
│       ├── 🟢 Node.js / Express / Prisma                                                       │
│       ├── 🐍 Python / FastAPI / Pydantic  ← NEW                                               │
│       └── 🦀 Go / Fiber (planned)                                                             │
│       ↓                                                                                        │
│  📤 Output + Embedded Signature + Hybrid Adapter + Runtime Verification                       │
│                                                                                               │
└─────────────────────────────────────────────────────────────────────────────────┘

📁 Project Structure

madilang/
├── madilang/              # 🧠 Core sovereign package
│   ├── compiler/          # 🔍 Parser, AST, Analyzer
│   ├── ir/                # ⚙️ IR + Signature Engine
│   ├── generators/        # 🏗️ Code generators
│   │   ├── nodejs/        #   🟢 Express + Prisma + Hybrid Adapter
│   │   └── python/        #   🐍 FastAPI + Pydantic + Hybrid Adapter ← NEW
│   ├── diagnostics/       # 🩺 Environment, Secrets, Network checks ← NEW
│   ├── stdlib/            # 📚 Auth, Validation, Security
│   ├── plugins/           # 🧩 Plugin system
│   └── cli/               # 🖥️ Modular CLI (lazy-loaded commands)
│       └── commands/      #   init, run, build, verify, check, doctor
├── tests/                 # 🧪 Comprehensive test suite
├── examples/              # 💡 Ready-to-run examples
├── tools/                 # 🤖 VSCode extension, dev tools
└── .github/workflows/     # 🔄 CI/CD pipeline (10/10 green ✅)

---

🔐 Sovereign Intent Signature

Every artifact generated by MadiLang carries a cryptographic signature that proves:

• 👤 Who authored the original intent
• 📝 What the intent was (source hash)
• 📅 When it was generated
• 🛡️ Whether it passed ethical review
• ✅ Integrity — any modification breaks verification

🔍 Verify Signature

madi verify output.js
# ✅ Signature structure valid
# 👤 Developer: madani004
# 📅 Generated: 2026-06-21T12:00:00Z
# 🔖 Intent Hash: a3f8c2...
# 🛡️ Ethics Score: 0.95

---

🛡️ Ethics & Security by Default

Check	Description
🔒 Secure Fields	Fields marked (secure) are automatically hashed with bcrypt
🔐 Auth Coverage	Sensitive routes require authentication protection
👤 Role Guards	Admin operations enforce role-based access control
🚫 Injection Prevention	Input validation generated for all inputs
⚠️ Error Safety	Generic error messages prevent data leakage
🧠 Ethics Scoring	Privacy, consent, transparency, accountability, fairness

madi check auth.madi
# ✅ Analysis passed
#    Entities: 1
#    Intents: 2

---

🚀 CLI Commands

# Initialize new project
madi init my-project

# Compile and run (Node.js or Python)
madi run src/main.madi --target nodejs
madi run src/main.madi --target python

# Build without running
madi build src/main.madi --target python --output dist/

# Verify sovereign signature
madi verify dist/output.js

# Analyze and validate source
madi check src/main.madi

# Diagnose environment ← NEW in v0.5.0
madi doctor

# Show version
madi --version

---

📦 Installation

🔧 From Source

git clone https://github.com/madanimkhitar22-beep/madilang.git
cd madilang
pip install -e .
madi doctor  # Verify your environment

🐍 From PyPI (Coming Soon)

pip install madilang

📋 Requirements

• Python 3.8+ (3.13 supported ✅)
• Node.js 18+ (for Node.js target)
• npm (for auto-dependency installation)

---

🧬 Philosophy

MadiLang is built on the Mkhitarian Ontology:

Human intent is the sovereign layer. Code is merely the execution of will. Ethics and security are not features — they are foundations.

🔗 Related Projects

• Mkhitarian Philosophy — The philosophical foundation
• Sovereign-Cognition-Engine — Ethics evaluation engine
• Sovereign-DevKit — Security scanning toolkit

---

🤝 Join the Sovereign Movement

💬 Discussions

👉 Join the Discussions

📋 Development Setup

git clone https://github.com/your-username/madilang.git
cd madilang
pip install -e ".[dev]"
pytest tests/ -v
ruff check .

📜 Governance

• Code of Conduct
• Security Policy
• License — MIT

---

📜 Changelog

See CHANGELOG.md for detailed release notes.

🚀 v0.5.0 Highlights

• 🐍 Python/FastAPI generator with Pydantic models and async handlers
• 🩺 madi doctor command for comprehensive environment diagnostics
• 🛡️ Sovereign Hybrid Adapter for zero-config database fallback
• 🏗️ Modular CLI with lazy-loaded command architecture
• ✅ 10/10 CI checks passing across Python 3.8–3.13
• 📱 Mobile-first verified on Termux/Android

🏛️ v0.4.0 Foundation

• ✨ Complete architecture rewrite with modular design
• 🔐 Sovereign Intent Signature system
• 🧩 Plugin system for extensibility
• 🛡️ Ethics and security hooks
• 🔄 CI/CD pipeline with quality, security, and integration checks

---

🔮 Roadmap

v0.6.0 (Next)

• 📚 OpenAPI/Swagger auto-documentation
• 🧪 Auto-testing generator from intents
• 🔄 madi watch mode for live reload
• 📦 PyPI publication

v1.0.0 (Vision)

• 🦀 Go/Fiber generator
• 🔗 Pi Network integration for decentralized deployment
• 🧠 Sovereign-Cognition-Engine deep integration
• 🌍 Community plugin ecosystem
• 🎨 Full LSP support for VSCode

---

📄 Citation

cff-version: 1.2.0
title: "MadiLang"
authors:
  - family-names: "El Mkhitar"
    given-names: "El Madani"
    email: "[e-mail]"
version: "0.5.0"
date-released: 2026-06-21
license: "MIT"
repository-code: "https://github.com/madanimkhitar22-beep/madilang"

---

👤 Author

El Madani El Mkhitar 📧 [e-mail] 🌐 GitHub Profile

"Building sovereign tools for a decentralized future, one intent at a time."

---

🌟 If MadiLang resonates with your vision, please star the repository!

---

🧠 Code is no longer written. It is described. 🔐 Sovereignty is no longer optional. It is embedded. 🌍 The future of development is sovereign, ethical, and accessible to all.

```