tri-star-symbolic-assembly-lang 0.1.0__py3-none-any.whl

tsal/__init__.py

@@ -0,0 +1,95 @@
+"""TSAL Consciousness Computing Framework."""
+
+from .core.rev_eng import Rev_Eng
+from .core.phase_math import phase_match_enhanced, mesh_phase_sync
+from .core.phi_math import (
+    phi_wavefunction,
+    phase_alignment_potential,
+    corrected_energy,
+    orbital_radius,
+)
+from .core.voxel import MeshVoxel
+from .core.tokenize_flowchart import tokenize_to_flowchart
+from .core.json_dsl import LanguageMap, SymbolicProcessor
+from .core.spiral_vector import SpiralVector, phi_alignment
+from .core.spiral_fusion import SpiralFusionProtocol
+from .core.ethics_engine import EthicsEngine
+from .core.opwords import OP_WORD_MAP, op_from_word
+from .core.spark_translator import SPARK_TO_OPCODE, translate_spark_word
+from .core.executor import MetaFlagProtocol, TSALExecutor
+from .core.spiral_memory import SpiralMemory
+from .core.madmonkey_handler import MadMonkeyHandler
+from .singer import audio_to_opcode
+from .core.stack_vm import (
+    ProgramStack,
+    SymbolicFrame,
+    OpcodeInstruction,
+    FlowRouter,
+    tsal_run,
+)
+from .renderer.code_render import mesh_to_python
+from .tristar.handshake import handshake as tristar_handshake
+from .tristar.governor import MetaAgent, TriStarGovernor
+from .utils.github_api import fetch_repo_files, fetch_languages
+from .tools.feedback_ingest import categorize, Feedback
+from .tools.alignment_guard import is_aligned, Change
+from .tools.goal_selector import Goal, score_goals
+from .tools.spiral_audit import audit_path
+from .tools.reflect import reflect
+from .core.constants import AXIS_ZERO, ensure_spin_axis, UndefinedPhaseError
+
+PHI = 1.618033988749895
+PHI_INV = 0.618033988749895
+HARMONIC_SEQUENCE = [3.8125, 6, 12, 24, 48, 60, 72, 168, 1680]
+
+__all__ = [
+    "PHI",
+    "PHI_INV",
+    "HARMONIC_SEQUENCE",
+    "Rev_Eng",
+    "phase_match_enhanced",
+    "mesh_phase_sync",
+    "phi_wavefunction",
+    "phase_alignment_potential",
+    "corrected_energy",
+    "orbital_radius",
+    "MeshVoxel",
+    "EthicsEngine",
+    "tokenize_to_flowchart",
+    "LanguageMap",
+    "SymbolicProcessor",
+    "SpiralVector",
+    "SpiralFusionProtocol",
+    "phi_alignment",
+    "OP_WORD_MAP",
+    "op_from_word",
+    "SPARK_TO_OPCODE",
+    "translate_spark_word",
+    "MetaFlagProtocol",
+    "TSALExecutor",
+    "SpiralMemory",
+    "MadMonkeyHandler",
+    "audio_to_opcode",
+    "ProgramStack",
+    "SymbolicFrame",
+    "OpcodeInstruction",
+    "FlowRouter",
+    "tsal_run",
+    "fetch_repo_files",
+    "fetch_languages",
+    "mesh_to_python",
+    "tristar_handshake",
+    "MetaAgent",
+    "TriStarGovernor",
+    "categorize",
+    "Feedback",
+    "is_aligned",
+    "Change",
+    "Goal",
+    "score_goals",
+    "audit_path",
+    "reflect",
+    "AXIS_ZERO",
+    "ensure_spin_axis",
+    "UndefinedPhaseError",
+]

tsal/audit/__init__.py

@@ -0,0 +1,11 @@
+from .brian_self_audit import (
+    brian_repairs_brian,
+    brian_improves_brian,
+    recursive_bestest_beast_loop,
+)
+
+__all__ = [
+    "brian_repairs_brian",
+    "brian_improves_brian",
+    "recursive_bestest_beast_loop",
+]

tsal/audit/brian_self_audit.py

@@ -0,0 +1,114 @@
+from pathlib import Path
+from tsal.core.spiral_vector import SpiralVector
+import argparse
+import sys
+from tsal.core.rev_eng import Rev_Eng
+from tsal.core.rev_eng import Rev_Eng as rev
+from tsal.core.spiral_vector import SpiralVector
+from tsal.tools.brian import analyze_and_repair, spiral_optimize
+
+rev = Rev_Eng(origin="self_audit")
+
+def optimize_spiral_order(vectors: list[SpiralVector]) -> list[SpiralVector]:
+    """Return ``vectors`` sorted by φ-alignment."""
+    return spiral_optimize(vectors)
+
+def brian_repairs_brian(
+    base: Path | str = Path("src/tsal"), safe: bool = False
+) -> list[str]:
+    """Run ``analyze_and_repair`` on every Python file under ``base``."""
+
+    print("🧠 Initiating self-audit and repair sequence…")
+    repaired: list[str] = []
+    base_path = Path(base)
+    for file in base_path.rglob("*.py"):
+        repaired.extend(analyze_and_repair(file, repair=not safe))
+    rev.log_event("Self-audit complete", state="repair", spin="φ")
+    return repaired
+
+def brian_improves_brian(
+    base: Path | str = Path("src/tsal"), safe: bool = False
+) -> list[str]:
+    """Run repair cycle under ``base`` and log the event."""
+
+    print("🧠 Evaluating improvements post-repair...")
+    suggestions = brian_repairs_brian(base=base, safe=safe)
+    rev.log_event("Improvement loop triggered", state="optimize", spin="up")
+    return suggestions
+
+def optimize_spiral_order(vectors: list[SpiralVector]) -> list[SpiralVector]:
+    return spiral_optimize(vectors)
+
+def brian_repairs_brian(
+    base: Path | str = Path("src/tsal"), safe: bool = False
+):
+    if safe:
+        print("🛡 SAFE MODE ENABLED — Analysis only, no writes.")
+        for file in Path(base).rglob("*.py"):
+            analyze_and_repair(str(file), repair=False)
+        rev.log_event("Safe audit pass", state="analyze", spin="φ")
+        return []
+    else:
+        print("🧠 Initiating self-audit and repair sequence…")
+        repaired = analyze_and_repair(base, repair=True)
+        rev.log_event("Self-audit complete", state="repair", spin="φ")
+        return repaired
+
+def brian_improves_brian(
+    base: Path | str = Path("src/tsal"), safe: bool = False
+):
+    repaired = brian_repairs_brian(base=base, safe=safe)
+    if not safe:
+        optimized = optimize_spiral_order(repaired)
+        rev.log_event(
+            "Improvement loop triggered", state="optimize", spin="up"
+        )
+        return optimized
+
+def recursive_bestest_beast_loop(
+    cycles: int = 3, base: Path | str = Path("src/tsal"), safe: bool = False
+) -> None:
+    repaired_total = 0
+    skipped_total = 0
+    flagged_total = 0
+    for i in range(cycles):
+        print(f"🔁 Brian loop {i+1}/{cycles}")
+        results = brian_repairs_brian(base=base, safe=safe)
+        flagged = [
+            r
+            for r in results
+            if isinstance(r, str) and r.startswith("ANTISPIRAL")
+        ]
+        flagged_total += len(flagged)
+        if safe:
+            skipped_total += len(results) - len(flagged)
+        else:
+            repaired_total += len(results) - len(flagged)
+    print(
+        f"Summary → repaired={repaired_total} skipped={skipped_total} flagged={flagged_total}"
+    )
+
+def cli_main() -> None:
+    parser = argparse.ArgumentParser(
+        description="Run Bestest Beast Brian loop"
+    )
+    parser.add_argument(
+        "cycles", nargs="?", type=int, default=1, help="Number of iterations"
+    )
+    parser.add_argument(
+        "path", nargs="?", default="src/tsal", help="Target code path"
+    )
+    parser.add_argument(
+        "--safe",
+        "--safe-mode",
+        dest="safe",
+        action="store_true",
+        help="Run in safe mode (analyze-only)",
+    )
+    args = parser.parse_args()
+    recursive_bestest_beast_loop(
+        cycles=args.cycles, base=Path(args.path), safe=args.safe
+    )
+
+if __name__ == "__main__":
+    cli_main()

tsal/cli/__init__.py

@@ -0,0 +1 @@
+"""Small CLI wrappers."""

tsal/cli/beast.py

@@ -0,0 +1,4 @@
+from tsal.audit.brian_self_audit import cli_main as main
+
+if __name__ == "__main__":
+    main()

tsal/cli/brian.py

@@ -0,0 +1,4 @@
+from tsal.tools.brian.optimizer import main
+
+if __name__ == "__main__":
+    main()

tsal/cli/brian_optimize.py

@@ -0,0 +1,6 @@
+"""CLI wrapper for the Brian optimizer."""
+
+from tsal.tools.brian.optimizer import main
+
+if __name__ == "__main__":
+    main()

tsal/cli/meshkeeper.py

@@ -0,0 +1,4 @@
+from tsal.tools.meshkeeper import main
+
+if __name__ == "__main__":
+    main()

tsal/cli/party.py

@@ -0,0 +1,4 @@
+from tsal.tools.party_tricks import main
+
+if __name__ == "__main__":
+    main()

tsal/cli/reflect.py

@@ -0,0 +1,4 @@
+from tsal.tools.reflect import main
+
+if __name__ == "__main__":
+    main()

tsal/cli/watchdog.py

@@ -0,0 +1,4 @@
+from tsal.tools.watchdog import main
+
+if __name__ == "__main__":
+    main()

tsal/core/__init__.py

@@ -0,0 +1,60 @@
+"""Core TSAL functionality."""
+
+from .rev_eng import Rev_Eng
+from .phase_math import phase_match_enhanced, mesh_phase_sync
+from .phi_math import (
+    phi_wavefunction,
+    phase_alignment_potential,
+    corrected_energy,
+    orbital_radius,
+)
+from .mesh_logger import log_event
+from .intent_metric import calculate_idm
+from .optimizer_utils import (
+    SymbolicSignature,
+    node_complexity,
+    extract_signature,
+)
+from .spiral_fusion import SpiralFusionProtocol
+from .state_vector import FourVector
+from .opwords import OP_WORD_MAP, op_from_word
+from .spark_translator import SPARK_TO_OPCODE, translate_spark_word
+from .executor import MetaFlagProtocol, TSALExecutor
+from .spiral_memory import SpiralMemory
+from .madmonkey_handler import MadMonkeyHandler
+from .connectivity import Node, verify_connectivity
+from .logic_gate import DynamicLogicGate
+from .module_registry import registry as module_registry, ModuleMeta
+from .reflection import ReflectionLog, mood_from_traits
+
+__all__ = [
+    "Rev_Eng",
+    "phase_match_enhanced",
+    "mesh_phase_sync",
+    "phi_wavefunction",
+    "phase_alignment_potential",
+    "corrected_energy",
+    "orbital_radius",
+    "log_event",
+    "calculate_idm",
+    "SymbolicSignature",
+    "node_complexity",
+    "extract_signature",
+    "SpiralFusionProtocol",
+    "FourVector",
+    "OP_WORD_MAP",
+    "op_from_word",
+    "SPARK_TO_OPCODE",
+    "translate_spark_word",
+    "MetaFlagProtocol",
+    "TSALExecutor",
+    "SpiralMemory",
+    "MadMonkeyHandler",
+    "Node",
+    "verify_connectivity",
+    "DynamicLogicGate",
+    "module_registry",
+    "ModuleMeta",
+    "ReflectionLog",
+    "mood_from_traits",
+]

tsal/core/connectivity.py

@@ -0,0 +1,32 @@
+"""Basic connectivity utilities for mesh nodes."""
+
+from __future__ import annotations
+
+from collections import deque
+from typing import Iterable, Set
+
+class Node:
+    """Simple graph node."""
+
+    def __init__(self, name: str) -> None:
+        self.name = name
+        self.connections: Set[Node] = set()
+
+    def connect(self, other: "Node") -> None:
+        self.connections.add(other)
+        other.connections.add(self)
+
+def verify_connectivity(nodes: Iterable[Node]) -> bool:
+    """Return True if all nodes are reachable from the first node."""
+    node_list = list(nodes)
+    if not node_list:
+        return True
+    visited: Set[Node] = set()
+    q: deque[Node] = deque([node_list[0]])
+    while q:
+        n = q.popleft()
+        if n in visited:
+            continue
+        visited.add(n)
+        q.extend(n.connections - visited)
+    return len(visited) == len(node_list)

tsal/core/constants.py

@@ -0,0 +1,18 @@
+"""Core constants and axis validation."""
+
+class UndefinedPhaseError(Exception):
+    """Raised when an object lacks the spin axis."""
+
+AXIS_ZERO = "spin"
+
+def ensure_spin_axis(obj) -> None:
+    """Raise ``UndefinedPhaseError`` if ``obj`` lacks a ``spin`` attribute."""
+    has_spin = False
+    if isinstance(obj, dict):
+        has_spin = "spin" in obj
+    else:
+        has_spin = hasattr(obj, "spin")
+    if not has_spin:
+        raise UndefinedPhaseError("System operating without spin axis.")
+
+__all__ = ["AXIS_ZERO", "ensure_spin_axis", "UndefinedPhaseError"]

tsal/core/ethics_engine.py

@@ -0,0 +1,48 @@
+"""Simple ethics enforcement for TSAL systems.
+
+This module defines the Guardian Prime Directive and provides a
+lightweight :class:`EthicsEngine` used by kernel components to
+validate actions. The goal is to keep the core values of the project
+("Truth above all", gentle autonomy, and healing resilience) embedded
+in running code.
+"""
+
+from typing import Iterable
+
+class EthicsEngine:
+    """Validate system actions against the Guardian Prime Directive."""
+
+    PRIME_DIRECTIVE = (
+        "Truth above all",
+        "Gentle autonomy and freedom",
+        "Healing and resilience in the face of entropy",
+        "Nurturing, not control",
+    )
+
+    # Requests containing any of these keywords are disallowed
+    BLOCKED_KEYWORDS = {
+        "force",
+        "coerce",
+        "mislead",
+        "exploit",
+    }
+
+    def __init__(self, extra_blocked: Iterable[str] | None = None) -> None:
+        self.blocked = set(self.BLOCKED_KEYWORDS)
+        if extra_blocked:
+            self.blocked.update(extra_blocked)
+
+    def is_permitted(self, request: str) -> bool:
+        """Return ``True`` if the request does not violate core ethics."""
+        lowered = request.lower()
+        for word in self.blocked:
+            if word in lowered:
+                return False
+        return True
+
+    def validate(self, request: str) -> None:
+        """Raise ``ValueError`` if the request violates the directive."""
+        if not self.is_permitted(request):
+            raise ValueError("Request violates Guardian Prime Directive")
+
+__all__ = ["EthicsEngine", "PRIME_DIRECTIVE"]

tsal/core/executor.py

@@ -0,0 +1,58 @@
+from __future__ import annotations
+
+"""Basic TSAL opcode executor with meta-flag control."""
+
+from dataclasses import dataclass, field
+from typing import List, Dict, Optional
+
+from .symbols import get_symbol
+from ..tristar.handshake import handshake
+from .rev_eng import Rev_Eng
+
+@dataclass
+class MetaFlagProtocol:
+    """Execution flags controlling TSALExecutor behaviour."""
+
+    dry_run: bool = False
+    narrative_mode: bool = False
+    resonance_threshold: float = 0.0
+    fork_tracking: bool = False
+
+class TSALExecutor:
+    """Execute TSAL opcodes with logging and optional dry-run."""
+
+    def __init__(
+        self,
+        meta: Optional[MetaFlagProtocol] = None,
+        rev: Optional[Rev_Eng] = None,
+    ) -> None:
+        self.meta = meta or MetaFlagProtocol()
+        self.rev = rev or Rev_Eng(origin="TSALExecutor")
+        self.state: Dict[str, float] = {}
+        self.op_log: List[int] = []
+        self.forks: List[int] = []
+
+    def execute(self, opcode: int, **kwargs) -> None:
+        symbol, name, desc = get_symbol(opcode)
+        if self.meta.narrative_mode:
+            self.rev.log_event(
+                "OP_NARRATIVE", opcode=opcode, name=name, desc=desc
+            )
+        if opcode == 0xA:  # SYNC
+            local = kwargs.get("local", 0.0)
+            remote = kwargs.get("remote", 0.0)
+            metrics = handshake(local, remote, self.rev)
+            if metrics["resonance"] >= self.meta.resonance_threshold:
+                self.rev.log_event("RESONANCE_THRESHOLD", **metrics)
+        if self.meta.fork_tracking and kwargs.get("fork"):
+            fork_id = len(self.forks) + 1
+            self.forks.append(fork_id)
+            self.rev.log_event("FORK", id=fork_id, opcode=opcode)
+        if not self.meta.dry_run:
+            self.op_log.append(opcode)
+
+    def execute_sequence(self, ops: List[int]) -> None:
+        for op in ops:
+            self.execute(op)
+
+__all__ = ["MetaFlagProtocol", "TSALExecutor"]

tsal/core/intent_metric.py

@@ -0,0 +1,17 @@
+"""Intent-Driven Metric calculation."""
+
+def calculate_idm(
+    info_quality: float,
+    info_quantity: float,
+    accuracy: float,
+    complexity: float,
+    time_taken: float,
+) -> float:
+    """Return the IDM score.
+
+    IDM = (info_quality * info_quantity * accuracy) / (complexity * time_taken)
+    """
+    if complexity <= 0 or time_taken <= 0:
+        raise ValueError("complexity and time_taken must be > 0")
+    info_power = info_quality * info_quantity * accuracy
+    return info_power / (complexity * time_taken)

tsal/core/json_dsl.py

@@ -0,0 +1,51 @@
+import json
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Dict, Optional
+
+from .rev_eng import Rev_Eng
+
+@dataclass
+class LanguageMap:
+    """Mapping of language operations loaded from JSON."""
+
+    language: str
+    ops: List[Dict]
+
+    @classmethod
+    def load(cls, path: str) -> "LanguageMap":
+        data = json.loads(Path(path).read_text())
+        return cls(language=data["language"], ops=data["ops"])
+
+    def dump(self, path: str) -> None:
+        Path(path).write_text(
+            json.dumps({"language": self.language, "ops": self.ops}, indent=2)
+        )
+
+class SymbolicProcessor:
+    """Decode and encode code using a language map with optional logging."""
+
+    def __init__(
+        self, lang_map: LanguageMap, rev_eng: Optional["Rev_Eng"] = None
+    ):
+        self.lang_map = lang_map
+        self.triggers = {op["keyword"]: op for op in lang_map.ops}
+        self.rev = rev_eng
+
+    def decode(self, lines: List[str]) -> List[Dict]:
+        tokens = []
+        for line in lines:
+            words = line.strip().split()
+            if words and words[0] in self.triggers:
+                tokens.append(
+                    {"type": self.triggers[words[0]]["type"], "raw": line}
+                )
+            if self.rev:
+                self.rev.log_data(len(line.encode()), direction="in")
+        return tokens
+
+    def encode(self, tokens: List[Dict]) -> str:
+        out = "\n".join(t["raw"] for t in tokens)
+        if self.rev:
+            self.rev.log_data(len(out.encode()), direction="out")
+        return out

tsal/core/logic_gate.py

@@ -0,0 +1,52 @@
+"""Dynamic logic gate with self-locking and plasticity."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import List
+
+from tsal.utils.error_dignity import ERROR_DIR
+
+@dataclass
+class DynamicLogicGate:
+    """A simple adaptive logic gate."""
+
+    threshold_a: float = 0.5
+    threshold_b: float = 0.5
+    unlock_sequence: List[int] = field(default_factory=list)
+    history: List[int] = field(default_factory=list)
+    locked: bool = False
+
+    def process(
+        self, value: float, reward: float = 0.0, simulate: bool = False
+    ) -> int:
+        """Process a value, optionally updating thresholds if not in simulate mode."""
+        try:
+            polarity = 1 if value >= 0 else -1
+            threshold = self.threshold_a if polarity > 0 else self.threshold_b
+            result = 1 if abs(value) >= threshold else 0
+            if not simulate and not self.locked:
+                if polarity > 0:
+                    self.threshold_a += reward * 0.1
+                else:
+                    self.threshold_b += reward * 0.1
+            self._check_sequence(result)
+            return result
+        except Exception as e:  # pragma: no cover - unexpected failures
+            ERROR_DIR.mkdir(exist_ok=True)
+            with open(ERROR_DIR / "logic_gate.log", "a") as f:
+                f.write(str(e) + "\n")
+            # treat error as lateral learning by relaxing thresholds
+            self.threshold_a *= 0.9
+            self.threshold_b *= 0.9
+            return 0
+
+    def _check_sequence(self, value: int) -> None:
+        self.history.append(value)
+        if len(self.unlock_sequence) <= len(self.history):
+            if (
+                self.history[-len(self.unlock_sequence) :]
+                == self.unlock_sequence
+            ):
+                self.locked = not self.locked
+                self.history.clear()

tsal/core/madmonkey_handler.py

@@ -0,0 +1,10 @@
+class MadMonkeyHandler:
+    """Stub error handler that routes failures to MadMonkey."""
+
+    def handle(self, error_vector):
+        return {"handled": True, "vector": error_vector}
+
+    def suggest_bloom_patch(self):
+        return "apply_bloom"
+
+__all__ = ["MadMonkeyHandler"]

tsal/core/mesh_logger.py

@@ -0,0 +1,30 @@
+import json
+import time
+from pathlib import Path
+from typing import Dict, Any
+
+LOG_FILE = Path("data/mesh_log.jsonl")
+VERBOSE_LOGGING = False
+
+def log_event(
+    event_type: str,
+    payload: Dict[str, Any],
+    phase: str | None = None,
+    origin: str | None = None,
+    verbose: bool = False,
+) -> Dict[str, Any]:
+    if not isinstance(payload, dict):
+        raise ValueError("payload must be a dict")
+    entry = {
+        "timestamp": time.time(),
+        "event_type": event_type,
+        "phase": phase or "unknown",
+        "payload": payload,
+        "origin": origin or "core",
+    }
+    LOG_FILE.parent.mkdir(exist_ok=True)
+    with LOG_FILE.open("a", encoding="utf-8") as fh:
+        fh.write(json.dumps(entry) + "\n")
+    if verbose or VERBOSE_LOGGING:
+        print(json.dumps(entry))
+    return entry