sigillin 0.1.0__py3-none-any.whl

sigillin/__init__.py

@@ -0,0 +1,6 @@
+"""sigillin – the poetic-symbolic interface layer of the GenesisAeon stack."""
+
+__version__ = "0.1.0"
+__all__ = ["Sigil"]
+
+from .core import Sigil

sigillin/cli.py

@@ -0,0 +1,91 @@
+"""Sigillin CLI – sig validate / render / inspect / bridge."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+from .core import Sigil
+
+app = typer.Typer(
+    name="sig",
+    help="Sigillin CLI – poetic-symbolic sigil engine",
+    add_completion=False,
+)
+console = Console()
+
+_CREP_KEYS = ("coherence", "resonance", "emergence", "poetics")
+
+
+@app.command()
+def validate(
+    path: Path = typer.Argument(..., help="Path to sigil file (YAML/JSON/Markdown)"),
+) -> None:
+    """Validate a sigil against the CREP schema (Coherence · Resonance · Emergence)."""
+    if not path.exists():
+        console.print(f"[bold red]✗ File not found:[/] {path}")
+        raise typer.Exit(1)
+    sigil = Sigil(path)
+    if sigil.validate_crep():
+        console.print(f"[bold green]✓ Sigil valid – CREP-aligned[/]  ({path.name})")
+    else:
+        missing = [k for k in _CREP_KEYS if k not in sigil.data]
+        console.print(f"[bold red]✗ Sigil invalid[/]  ({path.name})")
+        console.print(f"  Missing CREP keys: [yellow]{', '.join(missing)}[/]")
+        raise typer.Exit(1)
+
+
+@app.command()
+def render(
+    path: Path = typer.Argument(..., help="Path to sigil file"),
+    depth: float = typer.Option(0.618, help="Fractal resonance depth (default: φ)"),
+) -> None:
+    """Render the MandalaMap resonance spectrum for a sigil."""
+    if not path.exists():
+        console.print(f"[bold red]✗ File not found:[/] {path}")
+        raise typer.Exit(1)
+    sigil = Sigil(path)
+    spectrum = sigil.render_mandala(depth)
+    console.print(f"[bold magenta]Mandala resonance peak:[/]  {spectrum.max():.4f}")
+    console.print(f"[bold magenta]Mandala resonance mean:[/]  {spectrum.mean():.4f}")
+    console.print(sigil.bind_to_field())
+
+
+@app.command()
+def inspect(
+    path: Path = typer.Argument(..., help="Path to sigil file"),
+) -> None:
+    """Inspect sigil fields in a rich table."""
+    if not path.exists():
+        console.print(f"[bold red]✗ File not found:[/] {path}")
+        raise typer.Exit(1)
+    sigil = Sigil(path)
+    table = Table(
+        title=f"Sigil: {path.name}",
+        show_header=True,
+        header_style="bold cyan",
+    )
+    table.add_column("Key", style="cyan")
+    table.add_column("Value")
+    for k, v in sigil.data.items():
+        table.add_row(str(k), str(v))
+    console.print(table)
+    crep_status = "[green]✓ valid[/]" if sigil.validate_crep() else "[red]✗ invalid[/]"
+    console.print(f"CREP status: {crep_status}")
+
+
+@app.command()
+def bridge(
+    provider: str = typer.Argument("openai", help="Provider name for bridge"),
+) -> None:
+    """Create a self-referential provider bridge."""
+    console.print(
+        f"[bold cyan]Selfmeta bridge for [white]{provider}[/white] created[/]"
+    )
+
+
+if __name__ == "__main__":
+    app()

sigillin/core.py

@@ -0,0 +1,129 @@
+"""SigilParser – trilayer YAML/JSON/Markdown loader with CREP validation."""
+
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+import yaml
+from rich.console import Console
+
+console = Console()
+
+CREP_KEYS = ("coherence", "resonance", "emergence", "poetics")
+
+
+class SigilValidationError(ValueError):
+    """Raised when a sigil fails CREP validation."""
+
+
+class Sigil:
+    """Self-referential poetic-symbolic attractor.
+
+    Supports three source formats (trilayer):
+    - ``.yaml`` / ``.yml``  — structural definition (primary)
+    - ``.json``             — machine-readable export
+    - ``.md``               — narrative / free-form (parses YAML front-matter)
+    """
+
+    def __init__(self, filepath: Path | str) -> None:
+        self.path = Path(filepath)
+        self.data: dict[str, Any] = self._load_trilayer()
+
+    # ------------------------------------------------------------------
+    # Trilayer loading
+    # ------------------------------------------------------------------
+
+    def _load_trilayer(self) -> dict[str, Any]:
+        suffix = self.path.suffix.lower()
+        if suffix in {".yaml", ".yml"}:
+            return self._load_yaml()
+        if suffix == ".json":
+            return self._load_json()
+        if suffix == ".md":
+            return self._load_markdown_frontmatter()
+        # Fallback: try YAML first, then JSON
+        try:
+            return self._load_yaml()
+        except Exception:
+            return self._load_json()
+
+    def _load_yaml(self) -> dict[str, Any]:
+        with self.path.open(encoding="utf-8") as f:
+            return yaml.safe_load(f) or {}
+
+    def _load_json(self) -> dict[str, Any]:
+        with self.path.open(encoding="utf-8") as f:
+            return json.load(f)
+
+    def _load_markdown_frontmatter(self) -> dict[str, Any]:
+        """Extract YAML front-matter between ``---`` fences."""
+        text = self.path.read_text(encoding="utf-8")
+        lines = text.splitlines()
+        if lines and lines[0].strip() == "---":
+            end = next(
+                (i for i, ln in enumerate(lines[1:], 1) if ln.strip() == "---"),
+                None,
+            )
+            if end is not None:
+                front = "\n".join(lines[1:end])
+                return yaml.safe_load(front) or {}
+        return {}
+
+    # ------------------------------------------------------------------
+    # CREP validation
+    # ------------------------------------------------------------------
+
+    def validate_crep(self) -> bool:
+        """Return True if all four CREP keys are present."""
+        return all(k in self.data for k in CREP_KEYS)
+
+    def assert_crep(self) -> None:
+        """Raise :class:`SigilValidationError` if CREP keys are missing."""
+        missing = [k for k in CREP_KEYS if k not in self.data]
+        if missing:
+            raise SigilValidationError(
+                f"Sigil {self.path.name!r} is missing CREP keys: {missing}"
+            )
+
+    # ------------------------------------------------------------------
+    # MandalaMap resonance
+    # ------------------------------------------------------------------
+
+    def render_mandala(self, depth: float = 0.618) -> np.ndarray:
+        """Return a fractal resonance spectrum (placeholder MandalaMap binding).
+
+        The golden-ratio depth parameter (φ ≈ 0.618) controls the oscillation
+        frequency.  The returned array can be handed to fieldtheory for full
+        Lagrangian integration when the ``[stack]`` extra is installed.
+        """
+        t = np.linspace(0, 10, 100)
+        return np.sin(t * depth) * 1.618  # φ-scaled resonance spectrum
+
+    # ------------------------------------------------------------------
+    # Optional fieldtheory binding
+    # ------------------------------------------------------------------
+
+    def bind_to_field(self) -> str:
+        """Bind this sigil to the fieldtheory Lagrangian (requires ``[stack]``)."""
+        try:
+            from fieldtheory.core import derive_lagrangian  # type: ignore[import]
+
+            return str(derive_lagrangian())
+        except ImportError:
+            return "Lagrangian binding available with: pip install sigillin[stack]"
+
+    # ------------------------------------------------------------------
+    # Dunder helpers
+    # ------------------------------------------------------------------
+
+    def __repr__(self) -> str:
+        return f"Sigil(path={self.path!r}, crep_valid={self.validate_crep()})"
+
+    def __getitem__(self, key: str) -> Any:
+        return self.data[key]
+
+    def get(self, key: str, default: Any = None) -> Any:
+        return self.data.get(key, default)

sigillin/entropy_table_bridge.py

@@ -0,0 +1,50 @@
+"""entropy-table bridge – export sigillin data into entropy-table format.
+
+Requires ``sigillin[stack]`` (``entropy-table>=1.0.1``).
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from .core import Sigil
+
+
+def sigil_to_entropy_record(sigil: Sigil) -> dict[str, Any]:
+    """Convert a :class:`Sigil` to a flat entropy-table record.
+
+    The record schema mirrors the trilayer CREP structure so that it can be
+    ingested directly by ``entropy_table.register()``.
+    """
+    spectrum = sigil.render_mandala()
+    return {
+        "name": sigil.path.stem,
+        "coherence": sigil.get("coherence", 0.0),
+        "resonance": sigil.get("resonance", 0.0),
+        "emergence": sigil.get("emergence", 0.0),
+        "poetics": sigil.get("poetics", ""),
+        "mandala_peak": float(spectrum.max()),
+        "mandala_mean": float(spectrum.mean()),
+        "source_path": str(sigil.path),
+        "crep_valid": sigil.validate_crep(),
+    }
+
+
+def export_to_entropy_table(path: Path | str) -> None:
+    """Load a sigil and register it with entropy-table (requires ``[stack]``).
+
+    Raises :class:`ImportError` with a helpful message when the ``[stack]``
+    extra is not installed.
+    """
+    try:
+        from entropy_table import register  # type: ignore[import]
+    except ImportError as exc:
+        raise ImportError(
+            "entropy-table is not installed. "
+            "Install it with: pip install sigillin[stack]"
+        ) from exc
+
+    sigil = Sigil(path)
+    record = sigil_to_entropy_record(sigil)
+    register(record)

sigillin-0.1.0.dist-info/METADATA

@@ -0,0 +1,163 @@
+Metadata-Version: 2.4
+Name: sigillin
+Version: 0.1.0
+Summary: The poetic-symbolic interface layer of the GenesisAeon stack – self-referential sigil parser, trilayer validation (YAML/JSON/Markdown) and MandalaMap resonance.
+Project-URL: Repository, https://github.com/GenesisAeon/sigillin
+Project-URL: Issues, https://github.com/GenesisAeon/sigillin/issues
+Author-email: GenesisAeon Team <team@genesisaeon.org>
+License: MIT
+License-File: LICENSE
+Keywords: crep,genesisaeon,mandala,poetry,sigil,symbolic,trilayer
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Artistic Software
+Classifier: Topic :: Scientific/Engineering
+Requires-Python: >=3.11
+Requires-Dist: numpy>=1.26
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: rich>=13.0
+Requires-Dist: typer>=0.15.0
+Provides-Extra: dev
+Requires-Dist: pre-commit>=3.7.0; extra == 'dev'
+Requires-Dist: pytest-cov>=5.0; extra == 'dev'
+Requires-Dist: pytest>=8.0; extra == 'dev'
+Requires-Dist: ruff>=0.9; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.6; extra == 'docs'
+Requires-Dist: mkdocs>=1.6; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=0.27; extra == 'docs'
+Provides-Extra: stack
+Requires-Dist: cosmic-moment>=0.1.0; extra == 'stack'
+Requires-Dist: entropy-governance>=0.1.0; extra == 'stack'
+Requires-Dist: entropy-table>=1.0.1; extra == 'stack'
+Requires-Dist: fieldtheory>=0.1.0; extra == 'stack'
+Requires-Dist: implosive-genesis>=0.4.0; extra == 'stack'
+Requires-Dist: medium-modulation>=0.1.0; extra == 'stack'
+Description-Content-Type: text/markdown
+
+# sigillin
+
+**The poetic-symbolic interface layer** – self-referential sigils that bind fieldtheory,
+cosmic moments and entropy governance into living resonance.
+
+[![CI](https://github.com/GenesisAeon/sigillin/actions/workflows/ci.yml/badge.svg)](https://github.com/GenesisAeon/sigillin/actions/workflows/ci.yml)
+[![Python 3.11+](https://img.shields.io/badge/python-3.11%2B-blue)](https://www.python.org)
+[![License: MIT](https://img.shields.io/badge/License-MIT-green.svg)](LICENSE)
+[![PyPI](https://img.shields.io/pypi/v/sigillin)](https://pypi.org/project/sigillin/)
+
+---
+
+## Install
+
+```bash
+pip install sigillin
+# or
+uv add sigillin
+
+# Full GenesisAeon stack integration
+pip install sigillin[stack]
+```
+
+## Usage
+
+```bash
+# Validate a sigil against the CREP schema
+sig validate codex-sigil.yaml
+
+# Render MandalaMap resonance spectrum
+sig render cosmic-web.yaml
+
+# Inspect sigil fields
+sig inspect codex-sigil.yaml
+
+# Create a self-referential provider bridge
+sig bridge openai
+```
+
+## Sigil format (trilayer: YAML / JSON / Markdown)
+
+Sigillin accepts three source formats:
+
+```yaml
+# codex-sigil.yaml
+coherence: 0.97
+resonance: 0.88
+emergence: 0.92
+poetics: "The first sigil – carrier of the primal pattern."
+```
+
+```json
+{ "coherence": 0.97, "resonance": 0.88, "emergence": 0.92, "poetics": "..." }
+```
+
+```markdown
+---
+coherence: 0.97
+resonance: 0.88
+emergence: 0.92
+poetics: "The first sigil – carrier of the primal pattern."
+---
+# Codex Prime
+
+Full narrative description here.
+```
+
+## CREP validation
+
+Every sigil is validated against four pillars:
+
+| Key | Meaning |
+|---|---|
+| `coherence` | Internal self-consistency |
+| `resonance` | Harmonic alignment with the field |
+| `emergence` | Capacity for novel pattern generation |
+| `poetics` | Narrative / symbolic intent |
+
+```python
+from sigillin import Sigil
+
+sigil = Sigil("codex-sigil.yaml")
+sigil.validate_crep()   # True / False
+sigil.assert_crep()     # raises SigilValidationError if invalid
+```
+
+## MandalaMap resonance
+
+```python
+spectrum = sigil.render_mandala(depth=0.618)  # φ-scaled resonance array
+print(f"Peak: {spectrum.max():.4f}")
+```
+
+## Stack integration
+
+With `pip install sigillin[stack]`, sigillin binds directly to the full GenesisAeon stack:
+
+```python
+sigil.bind_to_field()   # returns Lagrangian string from fieldtheory
+```
+
+```python
+from sigillin.entropy_table_bridge import export_to_entropy_table
+export_to_entropy_table("codex-sigil.yaml")
+```
+
+## Python API
+
+```python
+from sigillin import Sigil
+
+sigil = Sigil("codex-sigil.yaml")
+print(sigil["coherence"])          # 0.97
+print(sigil.get("tags", []))       # []
+print(repr(sigil))                 # Sigil(path=..., crep_valid=True)
+```
+
+---
+
+Built with [uv](https://docs.astral.sh/uv/) · [Typer](https://typer.tiangolo.com/) ·
+[Rich](https://rich.readthedocs.io/) · [NumPy](https://numpy.org/)

sigillin-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+sigillin/__init__.py,sha256=ozfIzO4lm3iTbieb_cGe4dZtqp7DwAZhrg4zXBgsJhQ,155
+sigillin/cli.py,sha256=jZEq7czcsxiXCHTQpH5h8bwfM_XliWb3l8Ir-emIUxE,2962
+sigillin/core.py,sha256=lTe8b-dfDvrF3Pj5tutKCv2669WIOBEtDpmoJni2o3k,4816
+sigillin/entropy_table_bridge.py,sha256=epZmwzpezuxl8LRJBwGC9CfH1pMMBKh0aenrjxBSMXM,1628
+sigillin-0.1.0.dist-info/METADATA,sha256=J4zvUYj9z4sxEfumXqG_4jxKWnqfpZBB5X_gErogjhA,4677
+sigillin-0.1.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+sigillin-0.1.0.dist-info/entry_points.txt,sha256=oAjYRRsx0ExRcOmqzhJDaI5W_fWRYEjLpVkRhujxnuU,41
+sigillin-0.1.0.dist-info/licenses/LICENSE,sha256=wSqMUOfr3YalZyMoR93_W327v9D9Z0BeOg5-DFn4g1g,1090
+sigillin-0.1.0.dist-info/RECORD,,

sigillin-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

sigillin-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+sig = sigillin.cli:app

sigillin-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 JohannRömer
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.