velm 0.1.2__py3-none-any.whl

velm/artisans/introspect/conductor.py

@@ -0,0 +1,80 @@
+# Path: artisans/introspect/conductor.py
+# --------------------------------------
+
+from typing import Dict, Any
+
+# --- The Divine Summons of the Pantheon ---
+from . import scaffold_scribe, ui_scribe, symphony_scribe, registry_scribe  # <--- NEW SUMMONS
+from ...core.artisan import BaseArtisan
+from ...interfaces.base import ScaffoldResult
+from ...interfaces.requests import IntrospectionRequest
+from ...logger import Scribe
+
+Logger = Scribe("IntrospectionConductor")
+
+
+class IntrospectionArtisan(BaseArtisan):
+    """
+    =================================================================================
+    == THE GNOSTIC CONDUCTOR OF SELF-AWARENESS (V-Ω-ETERNAL-APOTHEOSIS-ULTIMA++)   ==
+    =================================================================================
+    LIF: 10,000,000,000,000,000,000,000,000
+
+    This is the one true, sovereign Oracle of the Scaffold God-Engine.
+    It now possesses the **Gaze of the Registry**, capable of proclaiming the
+    CLI's own capabilities to the UI.
+    """
+
+    def __init__(self, engine):
+        super().__init__(engine)
+
+        # --- Rite 2: The Consecration (Enshrine the Scribe in the Pantheon) ---
+        self.pantheon = {
+            "scaffold_language": scaffold_scribe.proclaim_gnosis,
+            "symphony_language": symphony_scribe.proclaim_gnosis,
+            "ui_components": ui_scribe.proclaim_gnosis,
+            "registry": registry_scribe.proclaim_gnosis, # <--- THE NEW ALTAR
+        }
+        Logger.verbose(f"Gnostic Conductor consecrated with {len(self.pantheon)} Scribes.")
+
+    def execute(self, request: IntrospectionRequest) -> ScaffoldResult:
+        """
+        The Grand Symphony of Gnostic Revelation.
+        """
+        topic = request.topic
+        self.logger.info(f"The Conductor's Gaze is upon the Gnosis of: [cyan]{topic}[/cyan]")
+
+        try:
+            # --- MOVEMENT I: THE GAZE OF THE COSMOS (`all`) ---
+            if topic == "all":
+                all_gnosis: Dict[str, Any] = {}
+                for scribe_name, scribe_rite in self.pantheon.items():
+                    try:
+                        # [THE CURE]: Pass lite=True to prevent payload congestion
+                        # We use inspect to see if the scribe accepts the lite argument
+                        if 'lite' in inspect.signature(scribe_rite).parameters:
+                            all_gnosis[scribe_name] = scribe_rite(lite=True)
+                        else:
+                            all_gnosis[scribe_name] = scribe_rite()
+                    except Exception as e:
+                        all_gnosis[scribe_name] = {"error": str(e)}
+                return self.success("Canonical Gnosis proclaimed (Optimized).", data=all_gnosis)
+
+            # --- MOVEMENT II: THE DIVINE DELEGATION (SINGLE TOPIC) ---
+            scribe_rite = self.pantheon.get(topic)
+            if not scribe_rite:
+                # If topic isn't a direct scribe, check if it's a sub-key (e.g. "registry.translocate")
+                # For V1, we keep it simple.
+                known_topics = ", ".join(list(self.pantheon.keys()) + ['all'])
+                return self.failure(
+                    f"Unknown introspection topic: '{topic}'.",
+                    suggestion=f"Known topics are: {known_topics}"
+                )
+
+            # The Conductor commands the chosen Scribe to proclaim its truth.
+            data = scribe_rite()
+            return self.success(f"Gnosis for '{topic}' proclaimed.", data=data)
+
+        except Exception as e:
+            self.logger.error(f"A catastrophic paradox occurred during the Gaze for '{topic}'.", ex=e)
+            return self.failure(f"A catastrophic paradox shattered the Introspection Conductor's Gaze: {e}")

velm/artisans/introspect/registry_scribe.py

@@ -0,0 +1,109 @@
+# Path: artisans/introspect/registry_scribe.py
+# --------------------------------------------
+
+import inspect
+from typing import Dict, Any, List
+
+# --- THE DIVINE SUMMONS OF THE LAW ---
+from ...core.cli.grimoire import RITE_GRIMOIRE
+from ...logger import Scribe
+
+Logger = Scribe("RegistryScribe")
+
+
+class RegistryScribe:
+    """
+    =============================================================================
+    == THE SCRIBE OF THE GRIMOIRE (V-Ω-UI-METADATA-INJECTOR)                   ==
+    =============================================================================
+    LIF: 10,000,000,000
+
+    Transmutes the raw CLI `RITE_GRIMOIRE` into a rich, UI-ready manifest.
+    It applies Gnostic Heuristics to assign Categories, Icons, and Tags
+    dynamically, ensuring the Frontend receives a complete Soul.
+    """
+
+    # The Grimoire of Categories (Heuristic Mapping)
+    CATEGORY_MAP = {
+        "genesis": "Genesis", "init": "Genesis", "create": "Genesis",
+        "transmute": "Evolution", "patch": "Evolution", "translocate": "Evolution",
+        "conform": "Evolution", "refactor": "Evolution", "weave": "Evolution", "excise": "Evolution",
+        "architect": "Intelligence", "manifest": "Intelligence", "resurrect": "Intelligence",
+        "resonate": "Intelligence", "aether": "Intelligence", "ocular": "Intelligence",
+        "distill": "Perception", "analyze": "Perception", "mri": "Perception",
+        "graph": "Perception", "tree": "Perception", "read-soul": "Perception", "verify": "Perception",
+        "audit": "Security", "isolate": "Security", "fortify": "Security", "deploy": "Infrastructure",
+        "symphony": "Operations", "build": "Operations", "evolve": "Operations", "garden": "Operations",
+        "history": "Temporal", "undo": "Temporal", "holographic": "Temporal", "akasha": "Temporal",
+        "pad": "Interface", "studio": "Interface", "shell": "Interface", "gui": "Interface",
+    }
+
+    # The Grimoire of Icons (Lucide Names)
+    ICON_MAP = {
+        "genesis": "Zap", "init": "MessageSquare", "create": "PlusSquare",
+        "transmute": "RefreshCw", "translocate": "Move", "conform": "AlignCenter",
+        "patch": "Syringe", "refactor": "Hammer", "weave": "Cpu",
+        "architect": "BrainCircuit", "manifest": "Sparkles", "resurrect": "Flame",
+        "resonate": "Radio", "aether": "Wifi", "ocular": "Eye",
+        "distill": "Microscope", "analyze": "Activity", "mri": "HeartPulse",
+        "graph": "Map", "tree": "GitMerge", "verify": "ShieldCheck",
+        "audit": "Lock", "isolate": "ShieldAlert", "deploy": "Cloud",
+        "symphony": "Play", "build": "Hammer", "evolve": "Database",
+        "garden": "Scissors", "history": "History", "undo": "RotateCcw",
+        "holographic": "Camera", "akasha": "Library", "pad": "Layout",
+        "studio": "Monitor", "shell": "Terminal", "gui": "Box"
+    }
+
+    @classmethod
+    def proclaim_gnosis(cls) -> Dict[str, Any]:
+        """
+        The Rite of Reflection.
+        Returns a dictionary mapping Command IDs to GnosticTool definitions.
+        """
+        Logger.verbose("The Registry Scribe reads the Grimoire...")
+
+        registry_manifest = {}
+
+        for cmd_name, config in RITE_GRIMOIRE.items():
+            # 1. Divine Metadata
+            category = cls.CATEGORY_MAP.get(cmd_name, "Utilities")
+            icon = cls.ICON_MAP.get(cmd_name, "Box")
+
+            # 2. Divine Complexity
+            # If it has specific interaction flags or is a TUI, it is interactive.
+            complexity = "instant"
+            if "interactive" in str(config.get("flags", [])) or cmd_name in ["architect", "manifest", "pad", "studio",
+                                                                             "gui", "repl"]:
+                complexity = "interactive"
+            elif "daemon" in cmd_name:
+                complexity = "daemon"
+
+            # 3. Forge Tags
+            tags = [category]
+            if "subparsers" in config:
+                tags.append("Multi-Rite")
+                tags.extend(config["subparsers"].keys())
+
+            # 4. Construct the Gnostic Tool Object
+            # This schema matches the TypeScript `GnosticTool` interface exactly.
+            tool_definition = {
+                "id": cmd_name,
+                "name": cmd_name.replace("-", " ").title(),
+                "description": config.get("help", "No gnosis provided."),
+                "command": f"scaffold {cmd_name}",
+                "category": category,
+                "icon": icon,
+                "complexity": complexity,
+                "tags": tags,
+                "isPlugin": False  # Native rites are false
+            }
+
+            registry_manifest[cmd_name] = tool_definition
+
+        Logger.success(f"Registry Scribe has indexed {len(registry_manifest)} rites.")
+        return registry_manifest
+
+
+def proclaim_gnosis():
+    """Public gateway for the Conductor."""
+    return RegistryScribe.proclaim_gnosis()

velm/artisans/introspect/scaffold_scribe.py

@@ -0,0 +1,348 @@
+# C:/dev/scaffold-project/scaffold/artisans/introspect/scaffold_scribe.py
+
+import inspect
+from functools import lru_cache
+from pathlib import Path
+from typing import Dict, Any
+
+from ... import __version__ as scaffold_version
+from ...core.alchemist import get_alchemist
+from ...jurisprudence_core.scaffold_grammar_codex import ALLOWED_VAR_TYPES
+from ...semantic_injection.loader import SemanticRegistry
+
+PROJECT_ROOT = Path(__file__).resolve().parent.parent.parent.parent
+
+
+@lru_cache(maxsize=1024)
+def _get_gnostic_dossier(obj: Any, gnostic_type: str) -> Dict[str, Any]:
+    """
+    =================================================================================
+    == THE HYPER-SENTIENT GNOSTIC INQUISITOR (V-Ω-ETERNAL-APOTHEOSIS-FINALIS)      ==
+    =================================================================================
+    @gnosis:title The Gnostic Inquisitor
+    @gnosis:summary The final, ultra-definitive rite of object introspection.
+    @gnosis:LIF INFINITY
+    @gnosis:auth_code: )#(@()#@()#
+
+    This divine artisan performs the Grand Inquest upon a Python soul. It has been
+    bestowed with the 'Ward of Prudence', preventing it from attempting to
+    materialize the source of built-ins or foreign scriptures which causes
+    temporal stasis (hangs) in the Windows/Miniconda realm.
+    =================================================================================
+    """
+    # --- MOVEMENT I: THE PRE-FLIGHT GAZE (THE WARD OF PRUDENCE) ---
+    # Fast exit for souls that have no physical manifestation or belong to the C-Void.
+    if inspect.isbuiltin(obj) or not hasattr(obj, '__module__'):
+        return {
+            "description": "Built-in or C-Extension soul.",
+            "full_docstring": "Gnosis is encapsulated in the binary void.",
+            "gnostic_type": gnostic_type,
+            "source": None, "signature": None, "raw_source": None,
+            "id": f"{gnostic_type}:{getattr(obj, '__name__', 'built-in')}"
+        }
+
+    docstring = inspect.cleandoc(getattr(obj, '__doc__', "") or "")
+    description = docstring.splitlines()[0] if docstring else "No Gnosis provided."
+
+    dossier: Dict[str, Any] = {
+        "description": description,
+        "full_docstring": docstring,
+        "gnostic_type": gnostic_type,
+        "source": None,
+        "signature": None,
+        "raw_source": None,
+        "id": f"{gnostic_type}:{getattr(obj, '__name__', 'unknown')}"
+    }
+
+    try:
+        # --- MOVEMENT II: THE GAZE OF JURISDICTIONAL PURITY ---
+        # We determine the scripture's home before attempting to read its soul.
+        try:
+            file_path_str = inspect.getfile(obj)
+        except (TypeError, OSError):
+            return dossier  # Soul is ephemeral or dynamic
+
+        # [FACULTY: THE SINGULARITY ANCHOR]
+        # If the scripture dwells outside our project root, we do not attempt
+        # to extract its raw source, as it belongs to another god (3rd party lib).
+        if not file_path_str.startswith(str(PROJECT_ROOT)):
+            return dossier
+
+        file_path = Path(file_path_str)
+        relative_path = file_path.relative_to(PROJECT_ROOT)
+        dossier['id'] = f"{relative_path.as_posix()}:{obj.__name__}"
+
+        # --- MOVEMENT III: THE SURGICAL EXTRACTION ---
+        # We use the lines we've already found to forge the raw_source,
+        # avoiding a redundant and potentially hanging 'inspect.getsource' call.
+        source_lines, start_line = inspect.getsourcelines(obj)
+
+        dossier["source"] = {
+            "file": relative_path.as_posix(),
+            "line": start_line,
+            "end_line": start_line + len(source_lines)
+        }
+
+        # Transmute the list of lines back into a single, pure scripture.
+        dossier["raw_source"] = "".join(source_lines)
+
+    except (TypeError, OSError, ValueError, RecursionError):
+        # The Gaze is gracefully averted if a paradox is encountered.
+        pass
+
+    # --- MOVEMENT IV: THE SIGNATURE ALCHEMIST ---
+    try:
+        sig = inspect.signature(obj)
+
+        def _format_annotation(anno: Any) -> str:
+            if anno is inspect.Parameter.empty: return "Any"
+            # Support complex types like Union, Optional, etc.
+            return str(anno).replace("typing.", "")
+
+        def _format_default(val: Any) -> Any:
+            # We must not allow the default value to trigger its own introspection.
+            if val is inspect.Parameter.empty: return None
+            try:
+                return str(val) if not isinstance(val, (int, float, bool, str)) else val
+            except:
+                return "<Complex Value>"
+
+        dossier["signature"] = {
+            "return_annotation": _format_annotation(sig.return_annotation),
+            "parameters": [
+                {
+                    "name": param.name,
+                    "annotation": _format_annotation(param.annotation),
+                    "default": _format_default(param.default),
+                    "kind": str(param.kind)
+                }
+                for param in sig.parameters.values()
+            ]
+        }
+    except (ValueError, TypeError):
+        # A ward for souls whose signature is too complex for the mortal mind.
+        pass
+
+    return dossier
+
+
+def proclaim_gnosis(lite: bool = True) -> Dict[str, Any]:
+    """
+    [ASCENSION]: Restores the registry list with SMART-FULL logic.
+    """
+    if not SemanticRegistry._is_loaded:
+        SemanticRegistry.awaken()
+
+    semantic_domains = SemanticRegistry.list_domains()
+    semantic_directives = []
+    for domain, handler in SemanticRegistry._domains.items():
+        directives = [f"@{domain}/{d.replace('_directive_', '')}" for d in dir(handler) if d.startswith('_directive_')]
+        semantic_directives.extend(directives)
+
+    alchemist = get_alchemist()
+
+    # [THE CURE]: Metadata is Full, Source is Lazy.
+    # This allows the 105 Rites to be manifest without bloating the JSON.
+    def _dossier_stub(name: str, obj: Any, gtype: str) -> Dict:
+        doc = inspect.getdoc(obj) or "No Gnosis provided."
+        return {
+            "name": name,
+            "description": doc.splitlines()[0],
+            "full_docstring": doc if not lite else None,  # Include full docs but not source
+            "gnostic_type": gtype,
+            "signature_string": f"{name}()",
+            "raw_source": None  # Always lazy-load source via a separate 'resolveSource' rite
+        }
+
+    filters = [_dossier_stub(n, f, "filter") for n, f in sorted(alchemist.env.filters.items())]
+    functions = [_dossier_stub(n, f, "function") for n, f in sorted(alchemist.env.globals.items()) if
+                 callable(f) and not n.startswith('_')]
+
+
+    return {
+        "canon_version": "2.1.0",
+        "scaffold_version": scaffold_version,
+        "language": {
+            "id": "scaffold",
+            "name": "Scaffold Blueprint",
+            "description": "The Language of Form, a declarative scripture for defining the static structure and soul of a new reality."
+        },
+        "sigils": [
+            {
+                "token": "::",
+                "name": "Inline Content",
+                "description": "Inscribes a single-line or multi-line soul (content) directly into a scripture. This is the highest Gnostic precedence for content.",
+                "usage": "[path] :: \"...\" or [path] :: \"\"\"...\"\"\"",
+                "example": {
+                    "scripture": 'config.yml :: "version: 1.0.0"',
+                    "proclamation": "Forges a `config.yml` file containing the string `version: 1.0.0`."
+                }
+            },
+            {
+                "token": "<<",
+                "name": "External Seed",
+                "description": "Seeds a scripture's soul from an external file. The content of the seed file is subject to Alchemical Transmutation (variable injection).",
+                "usage": "[path] << [path/to/seed_file]",
+                "example": {
+                    "scripture": 'Dockerfile << ./seeds/python.dockerfile',
+                    "proclamation": "Forges a `Dockerfile` whose content is a copy of the `./seeds/python.dockerfile` file."
+                }
+            },
+            {
+                "token": "%%",
+                "name": "Permissions / Maestro's Will",
+                "description": "A dual-souled sigil. When used on a scripture line, it bestows executable permissions (e.g., `%% 755`). When used as a block header, it begins the Maestro's Edicts (`%% post-run`), an automation block executed after creation.",
+                "usage": "[path] :: \"...\" %% 755  OR  %% post-run",
+                "example": {
+                    "scripture": 'scripts/deploy.sh %% 755',
+                    "proclamation": "Makes the `deploy.sh` scripture executable."
+                }
+            },
+            {
+                "token": "$$",
+                "name": "Variable Definition",
+                "description": "Defines a Gnostic variable, the foundational Gnosis for the Divine Alchemist to perform its transmutations. This is the primary method for making blueprints dynamic.",
+                "usage": "$$ [name]: [type] = [value]",
+                "example": {
+                    "scripture": '$$ project_name: str = "sentinel-api"',
+                    "proclamation": "Defines a variable named `project_name` with the value `sentinel-api`."
+                }
+            },
+            {
+                "token": "#",
+                "name": "Comment / Gnostic Meta-Tag",
+                "description": "A proclamation for the Architect's Gaze only. It can also be used for Gnostic Meta-Tags (e.g., `# @description: ...`) which are perceived by other artisans like the `weave` Altar.",
+                "usage": "# [comment text]",
+                "example": {
+                    "scripture": '# This is a sacred scripture.',
+                    "proclamation": "The line is ignored by the Creator but perceived by the Oracle."
+                }
+            }
+        ],
+        "variables": {
+            "description": "The system for injecting dynamic Gnosis into the blueprint, allowing for reusable and context-aware architectural patterns.",
+            "definition": {
+                "token": "$$",
+                "syntax": "$$ [variable_name]: [type] = [value]",
+                "notes": "The type hint is optional but recommended for clarity and future tooling.",
+                "allowed_types": sorted(list(ALLOWED_VAR_TYPES))
+            },
+            "usage": {
+                "token": "{{ ... }}",
+                "syntax": "{{ [variable_name] | [filter] }}",
+                "description": "The sacred vessel for Alchemical Transmutation. Used in paths, filenames, and content to inject the resolved value of a variable."
+            },
+            "dynamic_sources": [
+                {
+                    "token": "${...}",
+                    "name": "Environment Gnosis",
+                    "syntax": "${[ENV_VAR_NAME]:[default_value]}",
+                    "description": "Summons a variable from the system environment at the moment of creation. The default value is used if the environment variable is a void. This is the sacred rite for injecting secrets.",
+                    "example": {
+                        "scripture": '$$ db_password = ${DB_PASS:"default_secret"}',
+                        "proclamation": "The `db_password` variable will be filled by the `DB_PASS` environment variable, or `default_secret` if it's not set."
+                    }
+                },
+                {
+                    "token": "$(...)",
+                    "name": "Command Gnosis",
+                    "syntax": "$([shell_command])",
+                    "description": "Summons Gnosis from the living voice of the mortal realm. The standard output of the shell command is captured and used as the variable's value. This is a rite of profound power and must be conducted with care.",
+                    "example": {
+                        "scripture": '$$ git_branch = $(git rev-parse --abbrev-ref HEAD)',
+                        "proclamation": "The `git_branch` variable will be filled with the name of the current Git branch."
+                    }
+                }
+            ]
+        },
+        "directives": {
+            "description": "Sacred edicts beginning with the `@` sigil that bestow Gnostic logic, modularity, and validation upon a blueprint, transforming it into an intelligent architectural program.",
+            "pantheon": [
+                {
+                    "token": "@include",
+                    "name": "The Gnostic Includer",
+                    "syntax": "@include \"[relative/path/to/fragment.scaffold]\"",
+                    "description": "Performs a rite of Gnostic Composition. The scripture and soul of another blueprint are summoned and woven into the current reality at the point of invocation. This is the key to creating a modular, reusable library of architectural patterns.",
+                    "example": {
+                        "scripture": 'src/api/ ::\n    @include "./api_v1.scaffold"',
+                        "proclamation": "The entire structure defined in `api_v1.scaffold` will be materialized inside the `src/api/` directory."
+                    }
+                },
+                {
+                    "token": "@if / @elif / @else / @endif",
+                    "name": "The Logic Gate",
+                    "syntax": "@if {{ [condition] }}\n\t...\n@elif {{ [condition] }}\n\t...\n@else\n\t...\n@endif",
+                    "description": "A sacred Logic Gate that forges an entire sub-tree of reality only if a Gnostic condition is true. The condition is a pure Jinja2 expression. This is the primary rite for creating adaptive, multi-purpose blueprints.",
+                    "example": {
+                        "scripture": '@if {{ use_docker }}\n    Dockerfile\n@endif',
+                        "proclamation": "The `Dockerfile` will only be created if the `use_docker` variable is true."
+                    }
+                },
+                {
+                    "token": "if ... ->",
+                    "name": "The Single-Line Guard",
+                    "syntax": "@if {{ [condition] }} -> [path/to/item]",
+                    "description": "A concise form of the Logic Gate for a single scripture or sanctum. It is a vow that a reality should exist only if a condition is met, without the need for a closing `@endif`.",
+                    "example": {
+                        "scripture": '@if {{ create_env_file }} -> .env.example',
+                        "proclamation": "The `.env.example` file will be created only if `create_env_file` is true."
+                    }
+                },
+                {
+                    "token": "@def",
+                    "name": "Variable Definition (Alias)",
+                    "syntax": "@def [name] = [value]",
+                    "description": "A stylistic alias for the `$$` sigil, preferred by some Architects for its aesthetic harmony with other `@` directives. Its Gnostic function is identical.",
+                    "example": {
+                        "scripture": '@def api_version = "v2"',
+                        "proclamation": "Defines a variable named `api_version`."
+                    }
+                },
+                {
+                    "token": "@error / @warn / @print",
+                    "name": "The Build-Time Messengers",
+                    "syntax": "@[level] \"[message]\"",
+                    "description": "Allows the blueprint to speak directly to the Architect during the parsing phase. `@error` is a heresy that halts the symphony. `@warn` proclaims a non-critical paradox. `@print` proclaims simple Gnosis.",
+                    "example": {
+                        "scripture": '@if not {{ project_name }}\n    @error "A sacred name must be proclaimed!"\n@endif',
+                        "proclamation": "The creation rite will fail with a luminous error if the `project_name` variable is a void."
+                    }
+                }
+            ]
+        },
+        "automation": {
+            "description": "The system for inscribing executable Will into a blueprint, allowing for fully automated, one-command project setup.",
+            "pantheon": [
+                {
+                    "token": "%% post-run",
+                    "name": "The Maestro's Edicts",
+                    "syntax": "%% post-run\n\t[command_1]\n\t[command_2]",
+                    "description": "Begins a block of shell commands that will be conducted sequentially inside the newly forged project's root directory, but only if the entire symphony of creation completes without heresy. This is the sacred rite for initializing Git, installing dependencies, and conducting initial builds.",
+                    "example": {
+                        "scripture": "%% post-run\n\tgit init\n\tnpm install",
+                        "proclamation": "After all files are created, `git init` and `npm install` will be executed."
+                    }
+                },
+                {
+                    "token": "%% weave",
+                    "name": "The Master Weave",
+                    "syntax": "%% weave [archetype_name] [target_dir] --set [key=value]",
+                    "description": "A divine edict within an Orchestration Blueprint. It summons the `weave` artisan to conduct a sub-symphony, weaving another archetype into the reality being forged. This is the key to composing complex realities from simpler, reusable patterns.",
+                    "example": {
+                        "scripture": "%% weave api-resource src/domains --set name=User",
+                        "proclamation": "Summons the `weave` artisan to inject the `api-resource` pattern into the `src/domains` directory."
+                    }
+                }
+            ]
+        },
+        "alchemist_grimoire": {
+            "description": "The sacred Grimoire of the Divine Alchemist, revealing all known rites (filters and functions) for transmuting Gnosis within a `{{ ... }}` vessel.",
+            "filters": filters,
+            "functions": functions
+        },
+        "semantic_cortex": {
+            "description": "The Pantheon of Semantic Directives, a collection of hyper-intelligent, generative artisans that can be summoned with a single `@` plea to forge complex, production-grade realities from a high-level intent.",
+            "domains": sorted(list(semantic_domains.keys())),
+            "directives": sorted(semantic_directives)
+        }
+    }