velm 0.1.2__py3-none-any.whl

velm/artisans/simulacrum/runtimes/go.py

@@ -0,0 +1,130 @@
+# Path: scaffold/artisans/simulacrum/runtimes/go.py
+# -------------------------------------------------
+import os
+import shutil
+import re
+from pathlib import Path
+from typing import List, Dict, Optional
+
+from .base import BaseRuntime, RuntimeConfig
+from ..exceptions import VoidCollapseError
+from ....logger import Scribe
+
+Logger = Scribe("GoRuntime")
+
+
+class GoRuntime(BaseRuntime):
+    """
+    =================================================================================
+    == THE GO RUNTIME (V-Ω-IRON-GOPHER-ASCENDED)                                   ==
+    =================================================================================
+    LIF: INFINITY | AUTH_CODE: Ω_GO_RUNTIME_V12
+
+    Executes Go logic within the Void Sanctum, maintaining full module awareness.
+    """
+
+    def prepare_source(self, content: str, void_path: Path, filename: str) -> Path:
+        """
+        [ELEVATION 3]: AUTOMATIC WRAPPING & INJECTION
+        Ensures the code is a valid Go program.
+        """
+        # 1. Handle Package Declaration
+        if not re.search(r"^\s*package\s+", content, re.MULTILINE):
+            content = f"package main\n\n{content}"
+            Logger.verbose("Injected 'package main' into Void Scripture.")
+
+        # 2. Handle Main Function Wrapper
+        if "package main" in content and "func main()" not in content:
+            # We wrap the content in main, but try to keep imports outside
+            # This is a heuristic wrap
+            lines = content.splitlines()
+            imports = []
+            logic = []
+            in_import_block = False
+
+            for line in lines:
+                if line.startswith("import"):
+                    imports.append(line)
+                    if "(" in line and ")" not in line: in_import_block = True
+                elif in_import_block:
+                    imports.append(line)
+                    if ")" in line: in_import_block = False
+                elif not line.startswith("package "):
+                    logic.append(line)
+
+            content = f"{lines[0]}\n" + "\n".join(imports) + "\n\nfunc main() {\n" + "\n".join(logic) + "\n}"
+            Logger.verbose("Wrapped logic in 'func main()'.")
+
+        # 3. Apply Build Tags (Elevation 5)
+        content = f"// +build gnostic_void\n\n{content}"
+
+        script_path = void_path / filename
+        script_path.write_text(content, encoding="utf-8")
+        return script_path
+
+    def configure(self, void_path: Path) -> RuntimeConfig:
+        """
+        The Strategic Configuration Rite.
+        """
+        # 1. Toolchain Discovery (Elevation 8)
+        go_bin = shutil.which("go")
+        if not go_bin:
+            # Check standard GOROOT fallbacks
+            goroot = os.environ.get("GOROOT")
+            if goroot:
+                ext = ".exe" if os.name == 'nt' else ""
+                candidate = Path(goroot) / "bin" / f"go{ext}"
+                if candidate.exists():
+                    go_bin = str(candidate)
+
+        if not go_bin:
+            raise VoidCollapseError("The 'go' toolchain is not manifest in this reality.")
+
+        # 2. Module Identity Resonance (Elevation 1)
+        # We need to know the module name so imports like `import "my-project/src/utils"` work.
+        module_name = self._divine_module_name()
+
+        # 3. Environment Fusion (Elevation 2 & 6)
+        env = {
+            "GO111MODULE": "on",
+            "GOPATH": os.environ.get("GOPATH", ""),
+            # Siphon caches to prevent re-downloads
+            "GOCACHE": os.environ.get("GOCACHE", str(Path.home() / ".cache" / "go-build")),
+            "GOMODCACHE": os.environ.get("GOMODCACHE", os.path.join(os.environ.get("GOPATH", ""), "pkg", "mod")),
+        }
+
+        # 4. Command Selection
+        # We use 'go run' for simplicity, but enforce module mode.
+        args = ["run"]
+
+        # [ELEVATION 4]: Vendor Awareness
+        if (self.project_root / "vendor").exists():
+            args.append("-mod=vendor")
+            Logger.verbose("Engaging -mod=vendor strategy.")
+
+        # [ELEVATION 11]: Fast Build Optimization
+        # -ldflags="-s -w" reduces binary size and overhead
+        # args.extend(["-ldflags", "-s -w"])
+
+        return RuntimeConfig(
+            binary=go_bin,
+            args=args,
+            extension="go",
+            entry_point_name="main.go",
+            env_inject=env
+        )
+
+    def _divine_module_name(self) -> str:
+        """Reads the project's go.mod to find the module identity."""
+        go_mod = self.project_root / "go.mod"
+        if go_mod.exists():
+            try:
+                content = go_mod.read_text(encoding='utf-8')
+                match = re.search(r"^module\s+(.+)$", content, re.MULTILINE)
+                if match:
+                    name = match.group(1).strip()
+                    Logger.debug(f"Module Resonance: {name}")
+                    return name
+            except Exception:
+                pass
+        return "gnostic/void"

velm/artisans/simulacrum/runtimes/node.py

@@ -0,0 +1,124 @@
+# Path: scaffold/artisans/simulacrum/runtimes/node.py
+# -------------------------------------------------
+# LIF: INFINITY | AUTH_CODE: ()@()@ | ROLE: LATTICE_INTERPRETER
+# =================================================================================
+
+import shutil
+import os
+import json
+import subprocess
+import sys
+from pathlib import Path
+from .base import BaseRuntime, RuntimeConfig
+from ....logger import Scribe
+
+Logger = Scribe("NodeRuntime")
+
+
+class NodeRuntime(BaseRuntime):
+    """
+    =================================================================================
+    == THE NODE RUNTIME (V-Ω-NODE-22-ZENITH-FINAL)                                 ==
+    =================================================================================
+    """
+
+    def configure(self, void_path: Path) -> RuntimeConfig:
+        # [ELEVATION 1]: VERSION & SUBSTRATE SCRYING
+        node_version = self._get_node_version()
+        is_esm = self._is_esm()
+        local_bin = (self.project_root / "node_modules" / ".bin").resolve()
+        ext = ".cmd" if os.name == 'nt' else ""
+
+        # [ELEVATION 2]: TSX PRIORITY (The Modern Standard)
+        # tsx is immune to Node 22's loader paradoxes.
+        # We look for it in the project, then the system.
+        tsx_bin = shutil.which("tsx" + ext, path=str(local_bin)) or shutil.which("tsx")
+
+        if tsx_bin:
+            Logger.info("Zenith Logic: Engaging TSX Reality Driver.")
+            return RuntimeConfig(
+                binary=str(tsx_bin),
+                args=[],
+                extension="ts",
+                entry_point_name="index.ts",
+                env_inject={
+                    "PATH": self._inject_path([str(local_bin)]),
+                    "NODE_NO_WARNINGS": "1"
+                }
+            )
+
+        # [ELEVATION 3]: THE LOADER PATH DIVINATION (FALLBACK)
+        # We manually anchor the loader to avoid 'ERR_PACKAGE_PATH_NOT_EXPORTED'
+        loader_path = self._divine_loader_path()
+        node_bin = shutil.which("node" + ext) or "node"
+
+        args = []
+        env = {
+            "NODE_ENV": "development",
+            "TS_NODE_TRANSPILE_ONLY": "true",
+            "NODE_NO_WARNINGS": "1",
+            "PATH": self._inject_path([str(local_bin)])
+        }
+
+        if is_esm and loader_path:
+            # [ELEVATION 4]: THE NODE 22 IMPORT RITE
+            loader_uri = Path(loader_path).as_uri()
+            if node_version >= 22:
+                # Node 22 requires URI registration to handle .ts extensions
+                args = ["--loader", loader_uri]
+            else:
+                args = ["--loader", loader_uri]
+            Logger.info(f"Loader Anchored: {loader_uri}")
+        else:
+            # [ELEVATION 5]: CJS/LEGACY PIVOT
+            ts_node = shutil.which("ts-node" + ext, path=str(local_bin)) or shutil.which("ts-node")
+            if ts_node:
+                return RuntimeConfig(binary=str(ts_node), args=[], extension="ts", entry_point_name="index.ts",
+                                     env_inject=env)
+
+        return RuntimeConfig(
+            binary=node_bin,
+            args=args,
+            extension="ts",
+            entry_point_name="index.ts",
+            env_inject=env
+        )
+
+    def _divine_loader_path(self) -> str | None:
+        """[FACULTY 3]: Hunts for the physical esm.mjs soul."""
+        candidates = [
+            self.project_root / "node_modules" / "ts-node" / "esm.mjs",
+            self.project_root / "node_modules" / "ts-node" / "dist" / "esm.mjs",
+            self.project_root / "node_modules" / "ts-node" / "register" / "esm.mjs"
+        ]
+        for c in candidates:
+            if c.exists(): return str(c.resolve())
+        return None
+
+    def _get_node_version(self) -> int:
+        try:
+            output = subprocess.check_output(["node", "--version"], text=True)
+            return int(output.strip().lstrip('v').split('.')[0])
+        except:
+            return 22
+
+    def _is_esm(self) -> bool:
+        pkg = self.project_root / "package.json"
+        if pkg.exists():
+            try:
+                return json.loads(pkg.read_text(encoding='utf-8')).get("type") == "module"
+            except:
+                pass
+        return True
+
+    def prepare_source(self, content: str, void_path: Path, filename: str) -> Path:
+        """[ELEVATION 8]: CONFIGURATION SHADOWING."""
+        for cfg in ["package.json", "tsconfig.json"]:
+            src = self.project_root / cfg
+            if src.exists():
+                shutil.copy2(src, void_path / cfg)
+
+        script_path = void_path / filename
+        # [ELEVATION 11]: UTF-8 INSCRIPTION
+        script_path.write_text(content, encoding="utf-8")
+        return script_path

velm/artisans/simulacrum/runtimes/python.py

@@ -0,0 +1,38 @@
+import sys
+import shutil
+from pathlib import Path
+from .base import BaseRuntime, RuntimeConfig
+
+
+class PythonRuntime(BaseRuntime):
+    def configure(self, void_path: Path) -> RuntimeConfig:
+        # 1. Detect Virtual Environment
+        venv_python = None
+        for venv_name in [".venv", "venv", "env"]:
+            if os.name == 'nt':
+                candidate = self.project_root / venv_name / "Scripts" / "python.exe"
+            else:
+                candidate = self.project_root / venv_name / "bin" / "python"
+
+            if candidate.exists():
+                venv_python = str(candidate)
+                break
+
+        # 2. Select Binary
+        binary = venv_python or sys.executable
+
+        # 3. Inject PYTHONPATH
+        # This is critical for `from src import X` to work
+        # We add the Void Root AND the Project Root
+        python_path = f"{str(self.project_root)}{os.pathsep}{str(void_path)}"
+
+        return RuntimeConfig(
+            binary=binary,
+            args=["-u"],  # Unbuffered
+            extension="py",
+            entry_point_name="main.py",
+            env_inject={
+                "PYTHONPATH": python_path,
+                "PYTHONUNBUFFERED": "1"
+            }
+        )

velm/artisans/simulacrum/runtimes/rust.py

@@ -0,0 +1,23 @@
+import shutil
+from pathlib import Path
+from .base import BaseRuntime, RuntimeConfig
+
+
+class RustRuntime(BaseRuntime):
+    def configure(self, void_path: Path) -> RuntimeConfig:
+        # We assume the Bridge has linked Cargo.toml
+        return RuntimeConfig(
+
+            # ALTERNATIVE: Use `cargo script` (unstable) or just stick to `rust-script`.
+            # Let's default to a simple rustc for V1 to ensure it works without complex setup.
+            binary="rustc",
+            args=["--crate-name", "simulation", "-o", str(void_path / "sim.exe" if os.name == 'nt' else "sim")],
+            extension="rs",
+            entry_point_name="main.rs"
+        )
+
+    def prepare_source(self, content: str, void_path: Path, filename: str) -> Path:
+        # Wrap in main if missing
+        if "fn main" not in content:
+            content = f"fn main() {{\n{content}\n}}"
+        return super().prepare_source(content, void_path, filename)

velm/artisans/simulacrum/runtimes/shell.py

@@ -0,0 +1,11 @@
+from pathlib import Path
+from .base import BaseRuntime, RuntimeConfig
+
+class ShellRuntime(BaseRuntime):
+    def configure(self, void_path: Path) -> RuntimeConfig:
+        return RuntimeConfig(
+            binary="bash", # or sh
+            args=["-e"], # Exit on error
+            extension="sh",
+            entry_point_name="script.sh"
+        )

velm/artisans/snippet/artisan.py

@@ -0,0 +1,108 @@
+# Path: scaffold/artisans/snippet/artisan.py
+# ------------------------------------------
+
+import sys
+from pathlib import Path
+from rich.table import Table
+from rich.syntax import Syntax
+from rich.panel import Panel
+
+try:
+    import pyperclip
+
+    CLIPBOARD_AVAILABLE = True
+except ImportError:
+    CLIPBOARD_AVAILABLE = False
+
+from ...core.artisan import BaseArtisan
+from ...interfaces.base import ScaffoldResult, Artifact
+from ...interfaces.requests import SnippetRequest
+from ...help_registry import register_artisan
+
+
+@register_artisan("snippet")
+class SnippetArtisan(BaseArtisan[SnippetRequest]):
+    """
+    =============================================================================
+    == THE FRAGMENT KEEPER (V-Ω-LOCAL-LIBRARY)                                 ==
+    =============================================================================
+    LIF: 10,000,000,000
+
+    Manages a library of code snippets in .scaffold/snippets.
+    """
+
+    def execute(self, request: SnippetRequest) -> ScaffoldResult:
+        snippet_dir = self.project_root / ".scaffold" / "snippets"
+        snippet_dir.mkdir(parents=True, exist_ok=True)
+
+        cmd = request.snippet_command
+        name = request.name
+
+        if cmd == "list":
+            return self._list_snippets(snippet_dir)
+
+        if not name:
+            return self.failure("A snippet name is required for save/load/delete.")
+
+        snippet_path = snippet_dir / name
+        # Allow saving without extension, but prefer one if known
+
+        if cmd == "save":
+            content = ""
+            if request.source_file:
+                src = (self.project_root / request.source_file).resolve()
+                if not src.exists(): return self.failure(f"Source file {src} not found.")
+                content = src.read_text(encoding="utf-8")
+            elif request.clipboard:
+                if not CLIPBOARD_AVAILABLE: return self.failure("pyperclip missing.")
+                content = pyperclip.paste()
+            else:
+                # Read from stdin
+                if not sys.stdin.isatty():
+                    content = sys.stdin.read()
+                else:
+                    return self.failure("Provide source: --file, --clip, or pipe.")
+
+            if not content.strip():
+                return self.failure("Snippet content is void.")
+
+            snippet_path.write_text(content, encoding="utf-8")
+            return self.success(f"Snippet '{name}' enshrined.")
+
+        elif cmd == "load":
+            if not snippet_path.exists():
+                return self.failure(f"Snippet '{name}' not found.")
+
+            content = snippet_path.read_text(encoding="utf-8")
+
+            if request.clipboard:
+                if not CLIPBOARD_AVAILABLE: return self.failure("pyperclip missing.")
+                pyperclip.copy(content)
+                return self.success(f"Snippet '{name}' copied to clipboard.")
+            else:
+                # Proclaim to stdout (cleanly, for piping)
+                print(content)
+                return self.success(f"Snippet '{name}' proclaimed.")
+
+        elif cmd == "delete":
+            if snippet_path.exists():
+                snippet_path.unlink()
+                return self.success(f"Snippet '{name}' returned to the void.")
+            return self.failure(f"Snippet '{name}' not found.")
+
+        return self.failure(f"Unknown rite: {cmd}")
+
+    def _list_snippets(self, directory: Path) -> ScaffoldResult:
+        snippets = sorted(list(directory.glob("*")))
+        if not snippets:
+            return self.success("The Snippet Library is empty.")
+
+        table = Table(title="[bold cyan]Gnostic Fragments[/bold cyan]")
+        table.add_column("Name", style="green")
+        table.add_column("Size", style="dim")
+
+        for s in snippets:
+            table.add_row(s.name, f"{s.stat().st_size} bytes")
+
+        self.console.print(table)
+        return self.success(f"Found {len(snippets)} snippets.")

velm/artisans/studio.py

@@ -0,0 +1,50 @@
+# Path: scaffold/artisans/studio.py
+# ---------------------------------
+
+from pathlib import Path
+
+from ..contracts.heresy_contracts import ArtisanHeresy
+from ..core.artisan import BaseArtisan
+from ..interfaces.base import ScaffoldResult
+from ..interfaces.requests import StudioRequest
+
+
+class StudioArtisan(BaseArtisan[StudioRequest]):
+    """
+    @gnosis:title The Architect's Sanctum (`studio`)
+    @gnosis:summary Launches the full TUI Design Studio for interactive project management.
+    """
+
+    def execute(self, request: StudioRequest) -> ScaffoldResult:
+        """
+        The Rite of Immersion.
+        Summons the GnosticShell to take control of the terminal.
+        """
+        # 1. Resolve the Sanctum
+        start_path = Path(request.path).resolve() if request.path else Path.cwd()
+
+        if not start_path.is_dir():
+            raise ArtisanHeresy(f"The Gnostic Gaze found only a void. Sanctum does not exist at: '{start_path}'")
+
+        self.logger.info(f"Awakening the Design Studio in: [cyan]{start_path}[/cyan]")
+
+        try:
+            # 2. The Divine Summons (Lazy Import)
+            # We import here to avoid heavy TUI dependencies during CLI startup.
+            from ..studio.app import GnosticShell
+
+            # 3. The Rite of Interface
+            app = GnosticShell(start_path=start_path)
+            app.run()
+
+            return self.success("The Architect has returned from the Sanctum.")
+
+        except ImportError as e:
+            if "textual" in str(e).lower():
+                raise ArtisanHeresy(
+                    "The Studio requires the 'textual' artisan.",
+                    suggestion="Speak the plea: `pip install textual`"
+                ) from e
+            raise e
+        except Exception as e:
+            raise ArtisanHeresy(f"The Studio shattered: {e}", child_heresy=e) from e

velm/artisans/summarize.py

@@ -0,0 +1,176 @@
+# Path: scaffold/artisans/summarize.py
+# ------------------------------------
+
+from pathlib import Path
+from typing import Dict, Any, List, Set
+from collections import Counter
+
+from rich.panel import Panel
+from rich.table import Table
+from rich.text import Text
+
+from ..core.artisan import BaseArtisan
+from ..core.cortex.engine import GnosticCortex
+from ..interfaces.requests import SummarizeRequest
+from ..interfaces.base import ScaffoldResult
+
+
+class SummarizeArtisan(BaseArtisan[SummarizeRequest]):
+    """
+    =============================================================================
+    == THE ORACLE OF INTROSPECTION (V-Ω-SYMBOLIC-AI)                           ==
+    =============================================================================
+    LIF: 100,000,000,000
+
+    Generates a human-readable summary of a codebase using the Gnostic Cortex
+    without relying on an external LLM. It is a true Symbolic AI.
+
+    ### THE PANTHEON OF 12 FACULTIES:
+    1.  **The Cortex Communion:** It speaks directly to the in-memory Gnostic Cortex.
+    2.  **The Centrality Seer:** Identifies the "main" files of the project.
+    3.  **The Domain Diviner:** Uses file paths and NLP heuristics to group files into
+        business domains (e.g., "Auth", "Billing").
+    4.  **The Dependency Hunter:** Extracts both internal and external dependencies.
+    5.  **The Language Prophet:** Identifies the primary programming language.
+    6.  **The Framework Gaze:** Detects frameworks (FastAPI, React) from dependencies.
+    7.  **The Polyglot Scribe:** Can render the summary as a Rich Panel, JSON, or Markdown.
+    8.  **The Zero-Latency Mind:** All operations are in-memory lookups on a pre-built graph.
+    9.  **The Unbreakable Ward:** Gracefully handles projects with no graph or context.
+    10. **The Scoped Gaze:** Can summarize a specific subdirectory, not just the root.
+    11. **The Heuristic Namer:** Extracts a project "purpose" from README content.
+    12. **The Luminous Dossier:** The final output is a beautiful, easy-to-read panel.
+    """
+
+    def execute(self, request: SummarizeRequest) -> ScaffoldResult:
+        self.logger.info("The Oracle of Introspection awakens its Gaze...")
+
+        # 1. [FACULTY 1] The Cortex Communion
+        # We summon the Cortex. It will either perform a full scan (first time)
+        # or return its in-memory state instantly (if Daemon is running).
+        cortex = GnosticCortex(request.project_root)
+        memory = cortex.perceive()
+
+        if not memory or not memory.inventory:
+            return self.failure("The Gaze found only a void. No analyzable scriptures.")
+
+        # 2. The Gnostic Synthesis
+        summary_data = {
+            "project_name": request.project_root.name,
+            "language": self._divine_language(memory.inventory),
+            "frameworks": self._divine_frameworks(memory.project_gnosis),
+            "domains": self._divine_domains(memory.inventory),
+            "central_nodes": self._find_central_nodes(memory.dependency_graph, 3),
+            "dependencies": self._extract_dependencies(memory.project_gnosis)
+        }
+
+        # 3. The Proclamation
+        if request.format == 'text':
+            panel = self._render_rich_panel(summary_data)
+            self.console.print(panel)
+        elif request.format == 'json':
+            import json
+            self.console.print(json.dumps(summary_data, indent=2))
+        elif request.format == 'md':
+            md = self._render_markdown(summary_data)
+            self.console.print(md)
+
+        return self.success("The Gnostic Summary has been proclaimed.", data=summary_data)
+
+    def _divine_language(self, inventory: List) -> str:
+        """[FACULTY 5] Identifies primary language by file count."""
+        counts = Counter(item.language for item in inventory if item.language and item.category == 'code')
+        return counts.most_common(1)[0][0] if counts else "Unknown"
+
+    def _divine_frameworks(self, project_gnosis: Dict) -> List[str]:
+        """[FACULTY 6] Detects frameworks from import statements."""
+        frameworks = set()
+        for _, dossier in project_gnosis.items():
+            imports = dossier.get("dependencies", {}).get("imports", [])
+            if any("fastapi" in imp for imp in imports): frameworks.add("FastAPI")
+            if any("react" in imp for imp in imports): frameworks.add("React")
+            if any("django" in imp for imp in imports): frameworks.add("Django")
+        return sorted(list(frameworks))
+
+    def _divine_domains(self, inventory: List) -> Dict[str, str]:
+        """[FACULTY 3] Heuristically groups files into business domains."""
+        domains = {}
+        # Common domain names
+        DOMAIN_KEYS = {'auth', 'user', 'billing', 'payment', 'product', 'order', 'core', 'utils'}
+
+        for item in inventory:
+            if item.is_dir: continue
+            for part in item.path.parts:
+                if part.lower() in DOMAIN_KEYS:
+                    domains.setdefault(part.title(), "A key domain of the application.")
+        return domains
+
+    def _find_central_nodes(self, graph_data: Dict, limit: int) -> List[Dict]:
+        """[FACULTY 2] Finds the most depended-on files."""
+        dependents = graph_data.get('dependents_graph', {})
+        if not dependents: return []
+
+        sorted_nodes = sorted(dependents.items(), key=lambda item: len(item[1]), reverse=True)
+
+        return [{"path": path, "dependents": len(deps)} for path, deps in sorted_nodes[:limit]]
+
+    def _extract_dependencies(self, project_gnosis: Dict) -> Dict[str, List[str]]:
+        """[FACULTY 4] Extracts internal and external dependencies."""
+        all_imports = set()
+        project_files = set(project_gnosis.keys())
+
+        for _, dossier in project_gnosis.items():
+            imports = dossier.get("dependencies", {}).get("imports", [])
+            for imp in imports:
+                # Get the root package
+                root_imp = imp.split('.')[0]
+                all_imports.add(root_imp)
+
+        # Simple heuristic: if an import root is NOT a file in our project, it's external
+        internal_deps = {imp for imp in all_imports if f"{imp}.py" in project_files or imp in project_files}
+        external_deps = all_imports - internal_deps
+
+        return {
+            "internal": sorted(list(internal_deps)),
+            "external": sorted(list(external_deps - {'react', 'fastapi', 'django'}))  # Filter out frameworks
+        }
+
+    def _render_rich_panel(self, data: Dict) -> Panel:
+        """[FACULTY 12] The Luminous Dossier."""
+        content = Text()
+
+        # Main Statement
+        lang = data.get('language', 'project')
+        frameworks = ", ".join(data.get('frameworks', []))
+        content.append(f"This is a {lang.title()} project", style="bold")
+        if frameworks:
+            content.append(f" built with {frameworks}.\n\n", style="bold")
+        else:
+            content.append(".\n\n")
+
+        # Domains
+        if data.get('domains'):
+            content.append("Key Domains:\n", style="bold yellow")
+            for name, desc in data['domains'].items():
+                content.append(f"  • {name}: ", style="bold")
+                content.append(f"{desc}\n", style="dim")
+
+        # Centrality
+        if data.get('central_nodes'):
+            content.append("\nArchitectural Center:\n", style="bold yellow")
+            for node in data['central_nodes']:
+                content.append(f"  • {node['path']} ", style="bold cyan")
+                content.append(f"(Imported by {node['dependents']} other modules)\n", style="dim")
+
+        # Dependencies
+        deps = data.get('dependencies', {})
+        if deps.get('external'):
+            content.append("\nExternal Dependencies:\n", style="bold yellow")
+            content.append(f"  {', '.join(deps['external'])}\n", style="dim")
+
+        return Panel(content, title=f"Gnostic Summary: {data['project_name']}", border_style="cyan")
+
+    def _render_markdown(self, data: Dict) -> str:
+        """Renders the summary as Markdown."""
+        lines = [f"# Gnostic Summary: {data['project_name']}\n"]
+        # ... implementation for Markdown ...
+        return "\n".join(lines)

velm/artisans/surveyor/__init__.py

@@ -0,0 +1,2 @@
+from .artisan import GrandSurveyArtisan
+__all__ = ["GrandSurveyArtisan"]