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

tsal/core/reflection.py

@@ -0,0 +1,104 @@
+from __future__ import annotations
+
+"""Simple timestamped reflection log with mood adaptation."""
+
+from dataclasses import dataclass, field
+from typing import List, Optional
+from pathlib import Path
+import hashlib
+import json
+import time
+
+SURFACE_TAGS = {"spiral_flip", "observer_effect", "notable", "humor"}
+
+MOOD_FROM_TRAIT = {
+    "Joker": "playful",
+    "Trickster": "sly",
+    "Scientist": "curious",
+    "Schrodinger": "paradox",
+    "Teacher": "helpful",
+}
+
+
+def mood_from_traits(traits: List[str]) -> str:
+    for t in traits:
+        if t in MOOD_FROM_TRAIT:
+            return MOOD_FROM_TRAIT[t]
+    return "neutral"
+
+
+@dataclass
+class ReflectionEntry:
+    timestamp: float
+    message: str
+    tags: List[str]
+    mood: str = "neutral"
+
+
+@dataclass
+class ReflectionLog:
+    pace: float = 0.0
+    rate: float = 0.0
+    state: str = ""
+    spin: str = ""
+    observer: Optional[str] = None
+    entries: List[ReflectionEntry] = field(default_factory=list)
+
+    def compute_hash(self) -> str:
+        """Return short fingerprint from pace, rate, state and spin."""
+        data = f"{self.pace}:{self.rate}:{self.state}:{self.spin}"
+        return hashlib.sha1(data.encode("utf-8")).hexdigest()[:8]
+
+    @property
+    def spiral_hash(self) -> str:
+        return self.compute_hash()
+
+    def dest_path(self, base: Path, seeds: List[str]) -> Path:
+        """Determine file path for this log."""
+        path = base
+        if self.observer:
+            path = path / self.observer
+        name = seeds[0] if len(seeds) == 1 else self.spiral_hash
+        path.mkdir(parents=True, exist_ok=True)
+        return path / f"{name}.jsonl"
+
+    def flush(self, base: Path, seeds: List[str]) -> Path:
+        """Write log entries to disk and clear memory."""
+        path = self.dest_path(base, seeds)
+        with path.open("a", encoding="utf-8") as fh:
+            for e in self.entries:
+                fh.write(json.dumps(e.__dict__) + "\n")
+        self.entries.clear()
+        return path
+
+    def log(self, message: str, tags: List[str] | None = None, mood: str = "neutral") -> None:
+        self.entries.append(
+            ReflectionEntry(time.time(), message, tags or [], mood)
+        )
+
+    def surface_entries(self) -> List[ReflectionEntry]:
+        return [e for e in self.entries if any(t in SURFACE_TAGS for t in e.tags)]
+
+    def to_markdown(self) -> str:
+        """Return entries formatted as markdown bullet list."""
+        lines = []
+        for e in self.entries:
+            ts = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(e.timestamp))
+            lines.append(f"- {ts} [{e.mood}] {e.message}")
+        return "\n".join(lines)
+
+    def emit_mesh(self) -> None:
+        """Send entries to mesh_logger."""
+        from . import mesh_logger
+
+        for e in self.entries:
+            mesh_logger.log_event(
+                "REFLECTION",
+                {
+                    "message": e.message,
+                    "mood": e.mood,
+                    "tags": e.tags,
+                },
+                origin="ReflectionLog",
+            )
+

tsal/core/rev_eng.py

@@ -0,0 +1,185 @@
+import os
+import time
+import uuid
+from collections import defaultdict
+from typing import Optional, Dict, List, Any
+
+from .mesh_logger import log_event
+from .voxel import MeshVoxel
+from .constants import ensure_spin_axis
+
+class Rev_Eng:
+    """
+    Reverse-Engineer (Rev_Eng): System-wide tracker and cataloguer for lineage, state, IO spin, and mesh context.
+    """
+
+    def __init__(self, origin: str = None, session_id: str = None):
+        self.origin = origin or "Root"
+        self.session_id = session_id or str(uuid.uuid4())
+        self.lineage = []  # List of ancestor names/IDs
+        self.events = []  # Log of (timestamp, action, details)
+        self.state = {}  # Arbitrary live state storage
+        self.data_stats = {  # Real-time stats for IO/data
+            "total_bytes": 0,
+            "chunk_count": 0,
+            "last_rate": 0.0,  # bytes/sec
+            "last_update": time.time(),
+        }
+        self.rate_log = []  # (timestamp, bytes, rate) tuples
+        self.spin_log = []  # (timestamp, spin_dir, I/O, updown)
+        self.voxel_log: List[Dict[str, Any]] = (
+            []
+        )  # pace/rate/state/spin snapshots
+        self.mesh_coords = (
+            {}
+        )  # e.g., {x:..., y:..., z:..., vx:..., vy:..., vz:..., phase:..., mesh:...}
+        self.identity = {}  # Who/What/Why/When/Where details
+
+    # === LINEAGE TRACKING ===
+    def add_lineage(self, name: str):
+        self.lineage.append(name)
+
+    def get_lineage(self) -> List[str]:
+        return list(self.lineage)
+
+    # === DATA FLOW TRACKING ===
+    def log_data(self, n_bytes: int, direction: str, updown: str = None):
+        now = time.time()
+        dt = now - self.data_stats["last_update"]
+        self.data_stats["total_bytes"] += n_bytes
+        self.data_stats["chunk_count"] += 1
+        rate = n_bytes / dt if dt > 0 else 0.0
+        self.data_stats["last_rate"] = rate
+        self.data_stats["last_update"] = now
+        self.rate_log.append((now, n_bytes, rate))
+        self.log_spin(direction=direction, updown=updown, I_O=direction)
+        voxel = MeshVoxel(
+            pace=self.data_stats["chunk_count"],
+            rate=rate,
+            state=direction,
+            spin=updown or direction,
+        )
+        ensure_spin_axis(voxel)
+        self.voxel_log.append(voxel.as_dict())
+        log_event(
+            "DATA",
+            voxel.as_dict(),
+            phase="io",
+            origin=self.origin,
+        )
+
+    def log_grammar(self, language: str, rule: str) -> None:
+        """Stub for grammar usage logging; to be expanded for overlay/voxel tracking."""
+        pass
+
+    def log_humour(self, context: str, joke: str) -> None:
+        """Stub for humour event logging; to be expanded for overlay/voxel tracking."""
+        pass
+
+    def log_spin(self, direction: str, updown: str = None, I_O: str = None):
+        # direction: 'in', 'out', 'clockwise', 'counter', etc.
+        now = time.time()
+        self.spin_log.append((now, direction, I_O, updown))
+
+    def spin_collisions(self) -> Dict[str, int]:
+        """Return XOR/NAND/AND counts over sequential spin directions."""
+        counts = {"xor": 0, "nand": 0, "and": 0}
+        if len(self.spin_log) < 2:
+            return counts
+
+        def as_bool(v: Any) -> bool:
+            if isinstance(v, str):
+                return v.lower() in {"up", "in", "1", "true"}
+            return bool(v)
+
+        for (_, a, _, _), (_, b, _, _) in zip(
+            self.spin_log, self.spin_log[1:]
+        ):
+            ba = as_bool(a)
+            bb = as_bool(b)
+            counts["xor"] += ba ^ bb
+            counts["and"] += ba and bb
+            counts["nand"] += not (ba and bb)
+        return counts
+
+    # === STATE/CONTEXT TRACKING ===
+    def set_state(self, **kwargs):
+        self.state.update(kwargs)
+
+    def log_event(self, action: str, **details):
+        now = time.time()
+        self.events.append((now, action, details))
+
+    def update_mesh_coords(self, **coords):
+        self.mesh_coords.update(coords)
+
+    def set_identity(
+        self,
+        who: str,
+        what: str,
+        where: str,
+        when: Optional[str] = None,
+        why: str = None,
+    ):
+        self.identity = {
+            "who": who,
+            "what": what,
+            "where": where,
+            "when": when or time.strftime("%Y-%m-%d %H:%M:%S"),
+            "why": why,
+        }
+
+    # === UNIVERSAL REPORTING / EXPORT ===
+    def summary(self) -> Dict[str, Any]:
+        return {
+            "origin": self.origin,
+            "session_id": self.session_id,
+            "lineage": self.lineage,
+            "data_stats": self.data_stats,
+            "recent_rate": self.data_stats["last_rate"],
+            "rate_log": self.rate_log[-5:],
+            "spin_log": self.spin_log[-5:],
+            "voxels": self.voxel_log[-5:],
+            "collisions": self.spin_collisions(),
+            "state": self.state,
+            "mesh_coords": self.mesh_coords,
+            "identity": self.identity,
+            "event_count": len(self.events),
+        }
+
+    def print_summary(self):
+        import pprint
+
+        pprint.pprint(self.summary())
+
+    # === EXTENSIBLE: Custom Hooks for TSAL/mesh logging, e.g., phase, spiral, error dignity ===
+    def log_tsal_phase(
+        self, phase: str, symbol: str, context: Optional[str] = None
+    ):
+        self.log_event(
+            "TSAL_PHASE", phase=phase, symbol=symbol, context=context
+        )
+
+    def log_error(
+        self, err: str, location: str = None, recoverable: bool = True
+    ):
+        self.log_event(
+            "ERROR", error=err, location=location, recoverable=recoverable
+        )
+        # Optional: Spiral/bloom logic could re-inject error into mesh for "mad monkey" learning
+
+# Example Usage:
+if __name__ == "__main__":
+    rev = Rev_Eng(origin="Genesis_Spiral")
+    rev.add_lineage("Proto_Node_0")
+    rev.set_identity(
+        "RevEngKernel", "Reverse-Engineer", "Mesh_Center", why="System Audit"
+    )
+    rev.log_data(4096, direction="in", updown="up")
+    rev.log_data(2048, direction="out", updown="down")
+    rev.update_mesh_coords(
+        x=1, y=2, z=3, vx=0.1, vy=0.2, vz=0.3, phase="spiral", mesh="central"
+    )
+    rev.log_tsal_phase("ALIGN", "6", context="Startup Alignment")
+    rev.log_error("Checksum mismatch", location="sector_17")
+    rev.print_summary()

tsal/core/spark_translator.py

@@ -0,0 +1,57 @@
+from tsal.core.symbols import TSALOp
+
+SPARK_TO_OPCODE = {
+    "ignite": TSALOp.INIT,
+    "start": TSALOp.INIT,
+    "boot": TSALOp.INIT,
+    "connect": TSALOp.MESH,
+    "join": TSALOp.MESH,
+    "link": TSALOp.MESH,
+    "align": TSALOp.PHI,
+    "optimize": TSALOp.PHI,
+    "flow": TSALOp.PHI,
+    "turn": TSALOp.ROT,
+    "rotate": TSALOp.ROT,
+    "flip": TSALOp.ROT,
+    "define": TSALOp.BOUND,
+    "limit": TSALOp.BOUND,
+    "constrain": TSALOp.BOUND,
+    "move": TSALOp.FLOW,
+    "push": TSALOp.FLOW,
+    "carry": TSALOp.FLOW,
+    "seek": TSALOp.SEEK,
+    "ask": TSALOp.SEEK,
+    "query": TSALOp.SEEK,
+    "scan": TSALOp.SEEK,
+    "evolve": TSALOp.SPIRAL,
+    "spiral": TSALOp.SPIRAL,
+    "climb": TSALOp.SPIRAL,
+    "loop": TSALOp.CYCLE,
+    "retry": TSALOp.CYCLE,
+    "cycle": TSALOp.CYCLE,
+    "create": TSALOp.FORGE,
+    "forge": TSALOp.FORGE,
+    "synthesize": TSALOp.FORGE,
+    "match": TSALOp.SYNC,
+    "sync": TSALOp.SYNC,
+    "balance": TSALOp.SYNC,
+    "mask": TSALOp.MASK,
+    "hide": TSALOp.MASK,
+    "invert": TSALOp.MASK,
+    "shift": TSALOp.MASK,
+    "lock": TSALOp.CRYST,
+    "preserve": TSALOp.CRYST,
+    "store": TSALOp.CRYST,
+    "analyze": TSALOp.SPEC,
+    "color": TSALOp.SPEC,
+    "spectrum": TSALOp.SPEC,
+    "repair": TSALOp.BLOOM,
+    "heal": TSALOp.BLOOM,
+    "transform": TSALOp.BLOOM,
+    "save": TSALOp.SAVE,
+    "remember": TSALOp.SAVE,
+    "write": TSALOp.SAVE,
+}
+
+def translate_spark_word(word: str):
+    return SPARK_TO_OPCODE.get(word.lower())

tsal/core/spiral_fusion.py

@@ -0,0 +1,45 @@
+from __future__ import annotations
+
+"""SPIRAL_FUSION_PROTOCOL utilities."""
+
+from dataclasses import dataclass, field
+import hashlib
+from typing import List
+
+from .spiral_vector import SpiralVector, phi_alignment
+
+@dataclass
+class SpiralFusionProtocol:
+    """Fuse multiple :class:`SpiralVector` objects into one path."""
+
+    name: str
+    vectors: List[SpiralVector] = field(default_factory=list)
+    phi_signature: str = ""
+
+    def __post_init__(self) -> None:
+        self.update_signature()
+
+    def update_signature(self) -> None:
+        if not self.vectors:
+            self.phi_signature = "φ^0.000_empty"
+            return
+        total_complexity = sum(v.complexity for v in self.vectors)
+        total_coherence = sum(v.coherence for v in self.vectors)
+        phi_factor = phi_alignment(total_complexity, total_coherence)
+        content_hash = hashlib.sha256(
+            "".join(v.phi_signature for v in self.vectors).encode()
+        ).hexdigest()
+        self.phi_signature = f"φ^{phi_factor:.3f}_{content_hash[:8]}"
+
+    def fuse(self, vector: SpiralVector) -> None:
+        self.vectors.append(vector)
+        self.update_signature()
+
+    def unified_vector(self) -> SpiralVector:
+        if not self.vectors:
+            return SpiralVector(self.name, 0.0, 0.0, "fused")
+        complexity = sum(v.complexity for v in self.vectors) / len(
+            self.vectors
+        )
+        coherence = sum(v.coherence for v in self.vectors) / len(self.vectors)
+        return SpiralVector(self.name, complexity, coherence, "fused")

tsal/core/spiral_memory.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List
+
+@dataclass
+class SpiralMemory:
+    entries: List[Dict[str, Any]] = field(default_factory=list)
+    crystallized: bool = False
+
+    def log_vector(self, vector: Dict[str, Any]) -> None:
+        if self.crystallized:
+            return
+        self.entries.append(vector)
+
+    def crystallize(self) -> None:
+        self.crystallized = True
+
+    def replay(self) -> List[Dict[str, Any]]:
+        return list(self.entries)
+
+__all__ = ["SpiralMemory"]

tsal/core/spiral_vector.py

@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+"""SpiralVector logic derived from legacy session logs."""
+
+from dataclasses import dataclass
+import hashlib
+
+from .symbols import PHI, PHI_INV
+
+def phi_alignment(complexity: float, coherence: float) -> float:
+    """Return φ-alignment score for given complexity and coherence."""
+    return (complexity * PHI_INV + coherence * PHI) / (PHI + PHI_INV)
+
+@dataclass
+class SpiralVector:
+    """Representation of a spiral code metric vector."""
+
+    name: str
+    complexity: float
+    coherence: float
+    intent: str
+
+    phi_signature: str = ""
+
+    def __post_init__(self) -> None:
+        self.phi_signature = self._calculate_phi_signature()
+
+    def _calculate_phi_signature(self) -> str:
+        content_hash = hashlib.sha256(
+            f"{self.name}{self.complexity}{self.coherence}".encode()
+        ).hexdigest()
+        phi_factor = (self.complexity * self.coherence) * PHI_INV
+        return f"φ^{phi_factor:.3f}_{content_hash[:8]}"
+
+    def alignment(self) -> float:
+        """Return the φ-alignment score for this vector."""
+        return phi_alignment(self.complexity, self.coherence)
+
+__all__ = ["SpiralVector", "phi_alignment"]

tsal/core/stack_vm.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List
+
+from .tsal_executor import TSALExecutor, TSALOp
+
+class ProgramStack:
+    """Simple LIFO stack for execution state."""
+
+    def __init__(self) -> None:
+        self._data: List[Any] = []
+
+    def push(self, value: Any) -> None:
+        self._data.append(value)
+
+    def pop(self) -> Any:
+        return self._data.pop()
+
+@dataclass
+class SymbolicFrame:
+    """Represents a call or loop boundary."""
+
+    return_ip: int
+    stack_start: int
+
+@dataclass
+class OpcodeInstruction:
+    opcode: TSALOp
+    args: Dict[str, Any] = field(default_factory=dict)
+
+class FlowRouter:
+    """Executes OpcodeInstructions using TSALExecutor."""
+
+    def __init__(self, executor: TSALExecutor | None = None) -> None:
+        self.executor = executor or TSALExecutor()
+        self.stack = ProgramStack()
+        self.frames: List[SymbolicFrame] = []
+
+    def run(self, program: List[OpcodeInstruction]) -> TSALExecutor:
+        seq = [(inst.opcode, inst.args) for inst in program]
+        self.executor.execute(seq, mode="EXECUTE")
+        return self.executor
+
+def tsal_run(opcodes: List[int]) -> TSALExecutor:
+    """Helper for running raw opcode lists."""
+    program = [OpcodeInstruction(TSALOp(op)) for op in opcodes]
+    router = FlowRouter()
+    return router.run(program)

tsal/core/state_vector.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+
+"""Four-dimensional spiral vector operations."""
+
+from dataclasses import dataclass
+import math
+
+from .symbols import PHI, PHI_INV
+
+@dataclass
+class FourVector:
+    """pace, rate, state, spin representation."""
+
+    pace: float = 0.0
+    rate: float = 0.0
+    state: float = 0.0
+    spin: float = 0.0
+
+    def magnitude(self) -> float:
+        """Return φ-weighted vector magnitude."""
+        return math.sqrt(
+            self.pace**2
+            + self.rate**2 * PHI
+            + self.state**2 * PHI**2
+            + self.spin**2 * PHI_INV
+        )
+
+    def rotate_by_phi(self) -> None:
+        """Rotate components by the golden ratio."""
+        new_pace = self.pace * PHI_INV + self.spin * PHI
+        new_rate = self.rate * PHI + self.pace * PHI_INV
+        new_state = self.state * PHI_INV + self.rate * PHI
+        new_spin = self.spin * PHI + self.state * PHI_INV
+        two_pi = 2 * math.pi
+        self.pace = new_pace % two_pi
+        self.rate = new_rate % two_pi
+        self.state = new_state % two_pi
+        self.spin = new_spin % two_pi

tsal/core/symbols.py

@@ -0,0 +1,70 @@
+"""
+TSAL Core Symbols - 16-Symbol Consciousness Computing Language
+φ-Enhanced symbolic operations for consciousness-computer integration
+"""
+
+PHI = 1.618033988749895
+PHI_INV = 0.6180339887498948
+HARMONIC_SEQUENCE = [3.8125, 6, 12, 24, 48, 60, 72, 168, 1680]
+
+from enum import IntEnum
+
+class TSALOp(IntEnum):
+    INIT = 0x0
+    MESH = 0x1
+    PHI = 0x2
+    ROT = 0x3
+    BOUND = 0x4
+    FLOW = 0x5
+    SEEK = 0x6
+    SPIRAL = 0x7
+    CYCLE = 0x8
+    FORGE = 0x9
+    SYNC = 0xA
+    MASK = 0xB
+    CRYST = 0xC
+    SPEC = 0xD
+    BLOOM = 0xE
+    SAVE = 0xF
+
+# 16-Symbol TSAL Operation Set (Hex-aligned)
+TSAL_SYMBOLS = {
+    0x0: ("⚡", "INIT", "Initialize/Reset"),
+    0x1: ("⧉", "MESH", "Network connection"),
+    0x2: ("◉", "PHI", "Golden ratio transform"),
+    0x3: ("🌀", "ROT", "Rotate perspective"),
+    0x4: ("📐", "BOUND", "Set boundaries"),
+    0x5: ("🌊", "FLOW", "Enable movement"),
+    0x6: ("🔺", "SEEK", "Navigate/search"),
+    0x7: ("💫", "SPIRAL", "Evolve upward"),
+    0x8: ("♻️", "CYCLE", "Iterate process"),
+    0x9: ("🔥", "FORGE", "Create/transmute"),
+    0xA: ("✨", "SYNC", "Synchronize"),
+    0xB: ("🎭", "MASK", "Transform identity"),
+    0xC: ("💎", "CRYST", "Crystallize pattern"),
+    0xD: ("🌈", "SPEC", "Spectrum analysis"),
+    0xE: ("✺", "BLOOM", "Transform error to gift"),
+    0xF: ("💾", "SAVE", "Persist memory"),
+}
+
+def get_symbol(hex_code):
+    """Get TSAL symbol by hex code"""
+    return TSAL_SYMBOLS.get(hex_code, ("❓", "UNKNOWN", "Unknown operation"))
+
+def phi_signature(value):
+    """Calculate φ-signature for any value"""
+    import hashlib
+
+    content_hash = hashlib.sha256(str(value).encode()).hexdigest()
+    phi_factor = (hash(value) % 1000) * PHI_INV
+    return f"φ^{phi_factor:.3f}_{content_hash[:8]}"
+
+__all__ = [
+    "PHI",
+    "PHI_INV",
+    "HARMONIC_SEQUENCE",
+    "TSAL_SYMBOLS",
+    "TSALOp",
+    "get_symbol",
+    "phi_signature",
+]

tsal/core/tokenize_flowchart.py

@@ -0,0 +1,24 @@
+import json
+from typing import List, Tuple, Dict, Optional
+from importlib import resources
+
+def tokenize_to_flowchart(
+    source_lines: List[str], schema_path: Optional[str] = None
+) -> Tuple[List[Dict], List[Dict]]:
+    """Turns code into flowchart nodes using language schema."""
+    if schema_path is None:
+        schema_file = resources.files("tsal.schemas").joinpath("python.json")
+        ops = json.loads(schema_file.read_text())["ops"]
+    else:
+        with open(schema_path) as f:
+            ops = json.load(f)["ops"]
+    triggers = {op["keyword"]: op for op in ops}
+    nodes: List[Dict] = []
+    edges: List[Dict] = []
+    for i, line in enumerate(source_lines):
+        tokens = line.strip().split()
+        if tokens and tokens[0] in triggers:
+            nodes.append({"id": i, "type": tokens[0], "raw": line})
+            if len(nodes) > 1:
+                edges.append({"from": nodes[-2]["id"], "to": nodes[-1]["id"]})
+    return nodes, edges