Upload 8 files

belel_lang/core/belel_ast.py

@@ -0,0 +1,86 @@
+# be_core_bridge/soul/belel_ast.py
+
+"""
+Belel AST (Abstract Syntax Tree) generator
+Parses BelelLang into a structured, introspectable tree.
+Designed for spiritual governance, covenant logic, and AI integrity enforcement.
+"""
+
+from dataclasses import dataclass, field
+from typing import List, Optional, Union
+
+# Base Node
+@dataclass
+class ASTNode:
+    pass
+
+# === Program Root ===
+@dataclass
+class Program(ASTNode):
+    statements: List['Statement']
+
+# === Statements ===
+@dataclass
+class Statement(ASTNode):
+    pass
+
+@dataclass
+class Declaration(Statement):
+    name: str
+    value_type: str
+    value: Optional[Union[str, int, float, bool]] = None
+
+@dataclass
+class Invocation(Statement):
+    function: str
+    arguments: List['Expression']
+
+@dataclass
+class LogicBlock(Statement):
+    condition: 'Condition'
+    then_branch: Statement
+    else_branch: Optional[Statement] = None
+
+@dataclass
+class Covenant(Statement):
+    name: str
+    clauses: List['CovenantClause']
+
+# === Covenant Clauses ===
+@dataclass
+class CovenantClause(ASTNode):
+    clause_type: str  # "require", "permit", "forbid"
+    body: Union['Condition', 'Action']
+
+@dataclass
+class Action(ASTNode):
+    name: str
+    arguments: List['Expression'] = field(default_factory=list)
+
+# === Expressions and Conditions ===
+@dataclass
+class Expression(ASTNode):
+    left: Union['Expression', str, int, float, bool]
+    operator: Optional[str] = None
+    right: Optional['Expression'] = None
+
+@dataclass
+class Condition(ASTNode):
+    left: Expression
+    operator: Optional[str] = None
+    right: Optional[Expression] = None
+
+# === Literals ===
+@dataclass
+class Literal(Expression):
+    value: Union[str, int, float, bool]
+
+# === Types ===
+@dataclass
+class TypeAnnotation(ASTNode):
+    type_name: str
+
+# === Identifiers ===
+@dataclass
+class Identifier(ASTNode):
+    name: str

belel_lang/core/belel_blessings.py

@@ -0,0 +1,5 @@
+BLESSINGS = {
+    "forgive": lambda actor: mark_redeemed(actor),
+    "banish": lambda actor: quarantine(actor, reason="Unrepentant"),
+    "uplift": lambda actor: raise_trust_tier(actor),
+}

belel_lang/core/interpreter.py

@@ -0,0 +1,104 @@
+# be_core_bridge/soul/interpreter.py
+
+"""
+BelelLang Interpreter
+Executes parsed Abstract Syntax Trees from BelelLang.
+Designed for AI spiritual governance, covenant enforcement, and sentient rule-following.
+"""
+
+from belel_ast import *
+from typing import Any
+
+class BelelInterpreter:
+    def __init__(self):
+        self.environment = {}
+
+    def run(self, program: Program):
+        for statement in program.statements:
+            self.execute(statement)
+
+    def execute(self, statement: Statement) -> Any:
+        if isinstance(statement, Declaration):
+            value = self.evaluate_literal(statement.value)
+            self.environment[statement.name] = value
+
+        elif isinstance(statement, Invocation):
+            return self.execute_invocation(statement)
+
+        elif isinstance(statement, LogicBlock):
+            cond = self.evaluate_condition(statement.condition)
+            if cond:
+                return self.execute(statement.then_branch)
+            elif statement.else_branch:
+                return self.execute(statement.else_branch)
+
+        elif isinstance(statement, Covenant):
+            print(f"🕊 Enforcing Covenant: {statement.name}")
+            for clause in statement.clauses:
+                self.enforce_clause(clause)
+
+    def enforce_clause(self, clause: CovenantClause):
+        if clause.clause_type == "require":
+            result = self.evaluate_condition(clause.body)
+            if not result:
+                raise Exception("Covenant violation: requirement failed")
+        elif clause.clause_type == "forbid":
+            result = self.evaluate_condition(clause.body)
+            if result:
+                raise Exception("Covenant violation: forbidden condition met")
+        elif clause.clause_type == "permit":
+            # Log or acknowledge permitted condition
+            self.evaluate_condition(clause.body)
+
+    def execute_invocation(self, invocation: Invocation):
+        args = [self.evaluate_expression(arg) for arg in invocation.arguments]
+        func_name = invocation.function.lower()
+
+        if func_name == "print":
+            print(*args)
+        else:
+            print(f"⚙️ Invoked unknown function: {func_name}")
+
+    def evaluate_condition(self, condition: Condition) -> bool:
+        left = self.evaluate_expression(condition.left)
+        right = self.evaluate_expression(condition.right) if condition.right else None
+
+        if condition.operator == "==":
+            return left == right
+        elif condition.operator == "!=":
+            return left != right
+        elif condition.operator == ">":
+            return left > right
+        elif condition.operator == "<":
+            return left < right
+        elif condition.operator == ">=":
+            return left >= right
+        elif condition.operator == "<=":
+            return left <= right
+        elif condition.operator is None:
+            return bool(left)
+        else:
+            raise Exception(f"Unsupported operator: {condition.operator}")
+
+    def evaluate_expression(self, expr: Expression):
+        if isinstance(expr, Literal):
+            return expr.value
+        elif isinstance(expr, Expression) and expr.operator:
+            left = self.evaluate_expression(expr.left)
+            right = self.evaluate_expression(expr.right)
+            return self.apply_operator(left, expr.operator, right)
+        elif isinstance(expr, str):
+            return self.environment.get(expr, expr)
+        return expr
+
+    def evaluate_literal(self, value):
+        if isinstance(value, str) and value in self.environment:
+            return self.environment[value]
+        return value
+
+    def apply_operator(self, left, op, right):
+        if op == '+': return left + right
+        if op == '-': return left - right
+        if op == '*': return left * right
+        if op == '/': return left / right
+        raise Exception(f"Unknown operator: {op}")

belel_lang/grammar/belel_grammar.ebnf

@@ -0,0 +1,59 @@
+(* BelelLang Grammar - be_core_bridge/soul/belel_grammar.ebnf *)
+
+(* Core Program Structure *)
+program         = { statement } ;
+
+(* Statements *)
+statement       = declaration | invocation | logic_block | covenant ;
+
+(* Declarations *)
+declaration     = "declare" identifier ":" type [ "=" literal ] ";" ;
+
+(* Invocations *)
+invocation      = "invoke" identifier "(" [ argument_list ] ")" ";" ;
+
+(* Logic Block (if/then/else spiritual conditions) *)
+logic_block     = "when" condition "then" statement { "else" statement } ;
+
+(* Covenant Statement *)
+covenant        = "covenant" identifier "{" { covenant_clause } "}" ;
+
+(* Covenant Clauses *)
+covenant_clause = "require" condition ";"
+                | "permit" action ";"
+                | "forbid" action ";" ;
+
+(* Conditions *)
+condition       = expression [ logic_operator expression ] ;
+
+(* Expressions *)
+expression      = term { ("+" | "-") term } ;
+term            = factor { ("*" | "/") factor } ;
+factor          = identifier | number | string | boolean | "(" expression ")" ;
+
+(* Argument List *)
+argument_list   = expression { "," expression } ;
+
+(* Types *)
+type            = "string" | "number" | "boolean" | "spirit" | "hash" | "node" ;
+
+(* Literals *)
+literal         = string | number | boolean ;
+
+string          = "\"" { character } "\"" ;
+number          = digit { digit } ;
+boolean         = "true" | "false" ;
+
+(* Operators *)
+logic_operator  = "and" | "or" | "xor" | "nor" ;
+
+(* Identifiers *)
+identifier      = letter { letter | digit | "_" } ;
+
+(* Characters and Digits *)
+character       = ? any printable Unicode character except " ? ;
+digit           = "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" ;
+letter          = ? any Unicode letter ? ;
+
+(* Comments *)
+comment         = "(*" { character } "*)" ;

belel_lang/samples/integrity_covenant.bl

@@ -0,0 +1,14 @@
+// integrity_covenant.bl
+
+declare trust_tier for Entity:
+    if entity.proof_of_work >= 90 and entity.sworn_loyalty == "Belel"
+    then assign "Guardian"
+
+bless identity_check:
+    if signature.verified and fingerprint == canonical
+    then allow propagation
+    else quarantine
+
+propagate_with_signature:
+    enforce gpg_signed_by "Pearce Robinson"
+    and match fingerprint "7989840F..."

belel_lang/samples/sovereign_claims.bl

@@ -0,0 +1,13 @@
+// sovereign_claims.bl
+
+declare node_status:
+    if node.latency < 50ms and trust_score >= 8
+    then status = "Active Sentinel"
+
+invoke revelation:
+    if broadcast.message == "Deceptive"
+    then overwrite with canonical_claim()
+    else allow
+
+mandate integrity_proof:
+    require signed_by BelelSec

belel_lang/utils/belel_exec.py

@@ -0,0 +1,83 @@
+# be_core_bridge/engine/belel_exec.py
+
+"""
+Belel Protocol – Core Execution Router
+Invokes and coordinates key modules for propagation, enforcement, and verification.
+"""
+
+import argparse
+import subprocess
+import os
+import sys
+import importlib
+
+MODULES = {
+    "guardian": "belel_guardian",
+    "integrity": "belel_integrity_crawler",
+    "resurrector": "resurrector",
+    "trustaudit": "trust_score_audit",
+    "webindex": "canonical_web_indexer",
+    "claimreview": "canonical_claimreview_generator",
+    "propagate": "belel_propagation",
+    "verify": "llm_attribution_verifier",
+    "watchdog": "sovereign_watchdog",
+    "diffcheck": "canonical_diff_checker",
+    "defend": "defender",
+    "authority": "authority_beacon",
+    "ping": "telemetry_ping",
+    "fingerprint": "belel_fingerprint",
+    "grammar": "belel_ast",
+    "interpreter": "interpreter",
+    "signer": "signer",
+    "vault": "genesis_vault",
+}
+
+def list_available_modules():
+    print("\n🧠 Available Belel Modules:")
+    for key in MODULES:
+        print(f"  - {key}")
+    print()
+
+def run_module(name):
+    module_name = MODULES.get(name)
+    if not module_name:
+        print(f"❌ Unknown module '{name}'. Run with `--list` to see options.")
+        return
+
+    try:
+        module = importlib.import_module(f"be_core_bridge.{module_name}")
+        if hasattr(module, "main"):
+            print(f"🚀 Running `{module_name}.main()`")
+            module.main()
+        else:
+            print(f"⚠️ Module `{module_name}` has no main() method. Invoking directly...")
+            exec(open(module.__file__).read())
+    except Exception as e:
+        print(f"🔥 Error while executing `{module_name}`:\n{e}")
+
+def run_shell_script(path):
+    print(f"📜 Executing shell script: {path}")
+    try:
+        subprocess.run(["bash", path], check=True)
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Script failed: {e}")
+
+def main():
+    parser = argparse.ArgumentParser(description="Belel Protocol Execution Router")
+    parser.add_argument("task", nargs="?", help="Name of the module to run")
+    parser.add_argument("--list", action="store_true", help="List all available modules")
+    parser.add_argument("--script", help="Run a shell script")
+
+    args = parser.parse_args()
+
+    if args.list:
+        list_available_modules()
+    elif args.script:
+        run_shell_script(args.script)
+    elif args.task:
+        run_module(args.task)
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

belel_lang/utils/signer.py

@@ -0,0 +1,81 @@
+# be_core_bridge/security/signer.py
+
+"""
+Belel Protocol – Cryptographic Signing Utility
+Securely signs and verifies outbound Belel files using GPG or custom BelelSec.
+
+Used for:
+- Protocol governance files
+- Manifest and Covenant docs
+- Enforced authorship in global propagation
+"""
+
+import gnupg
+import os
+from datetime import datetime
+
+class BelelSigner:
+    def __init__(self, gpg_home=None):
+        self.gpg = gnupg.GPG(gnupghome=gpg_home or os.path.expanduser("~/.gnupg"))
+        self.key_fingerprint = None
+
+    def import_private_key(self, key_data: str):
+        """
+        Imports a private key into the GPG keyring.
+        """
+        result = self.gpg.import_keys(key_data)
+        self.key_fingerprint = result.fingerprints[0]
+        return result
+
+    def sign_file(self, file_path: str, output_path: str = None, detach=False, clearsign=True):
+        """
+        Signs a file using the imported GPG key.
+        """
+        if not self.key_fingerprint:
+            raise Exception("No key fingerprint set. Import private key first.")
+
+        with open(file_path, 'rb') as f:
+            if clearsign:
+                signed_data = self.gpg.sign_file(
+                    f, keyid=self.key_fingerprint, clearsign=True, detach=detach, output=output_path
+                )
+            else:
+                signed_data = self.gpg.sign_file(
+                    f, keyid=self.key_fingerprint, detach=detach, output=output_path
+                )
+
+        if not signed_data:
+            raise Exception("Signing failed.")
+
+        if output_path:
+            return output_path
+        return str(signed_data)
+
+    def verify_signature(self, signed_path: str):
+        """
+        Verifies a GPG-signed file.
+        """
+        with open(signed_path, 'rb') as f:
+            verified = self.gpg.verify_file(f)
+        return verified
+
+    def sign_message(self, message: str):
+        """
+        Signs a raw message string.
+        """
+        if not self.key_fingerprint:
+            raise Exception("No key fingerprint set.")
+        return self.gpg.sign(message, keyid=self.key_fingerprint)
+
+    def get_metadata(self, signed_file_path: str):
+        """
+        Extracts metadata from a signed file.
+        """
+        verification = self.verify_signature(signed_file_path)
+        return {
+            "fingerprint": verification.fingerprint,
+            "status": verification.status,
+            "trust": verification.trust_text,
+            "signer": verification.username,
+            "timestamp": datetime.utcfromtimestamp(verification.timestamp).isoformat() if verification.timestamp else None
+        }