velm 0.1.2__py3-none-any.whl

velm/core/jurisprudence/vows/docker_ops_vows.py

@@ -0,0 +1,65 @@
+import subprocess
+import json
+from typing import Tuple
+from .base import BaseVowHandler
+
+
+class DockerOpsVowHandlers(BaseVowHandler):
+    """
+    =============================================================================
+    == THE CELESTIAL INSPECTOR (V-Ω-INTRA-CONTAINER-GAZE)                      ==
+    =============================================================================
+    Judges the internal reality of running containers.
+    """
+
+    def _vow_container_running(self, container_name: str) -> Tuple[bool, str]:
+        """Asserts a specific container is UP."""
+        try:
+            res = subprocess.run(
+                ["docker", "inspect", "--format", "{{.State.Running}}", container_name],
+                capture_output=True, text=True
+            )
+            is_running = res.stdout.strip() == "true"
+            return is_running, f"Container '{container_name}' is {'running' if is_running else 'stopped'}."
+        except:
+            return False, f"Container '{container_name}' not found."
+
+    def _vow_container_healthy(self, container_name: str) -> Tuple[bool, str]:
+        """Asserts a container passes its HEALTHCHECK."""
+        try:
+            res = subprocess.run(
+                ["docker", "inspect", "--format", "{{.State.Health.Status}}", container_name],
+                capture_output=True, text=True
+            )
+            status = res.stdout.strip()
+            return status == "healthy", f"Container health is '{status}'."
+        except:
+            return False, f"Container '{container_name}' check failed."
+
+    def _vow_container_log_contains(self, container_name: str, text: str) -> Tuple[bool, str]:
+        """Gaze into the logs of a container."""
+        try:
+            res = subprocess.run(
+                ["docker", "logs", "--tail", "1000", container_name],
+                capture_output=True, text=True
+            )
+            logs = res.stdout + res.stderr
+            return text in logs, f"Log {'contains' if text in logs else 'lacks'} '{text}'."
+        except:
+            return False, f"Could not read logs for '{container_name}'."
+
+    def _vow_container_file_exists(self, container_name: str, file_path: str) -> Tuple[bool, str]:
+        """
+        The Teleporting Gaze. Checks if a file exists INSIDE the container.
+        Uses `docker exec` to run a lightweight check.
+        """
+        try:
+            # Use 'test -e' which works in sh, bash, ash (Alpine)
+            res = subprocess.run(
+                ["docker", "exec", container_name, "test", "-e", file_path],
+                capture_output=True
+            )
+            exists = res.returncode == 0
+            return exists, f"'{file_path}' {'exists' if exists else 'missing'} inside '{container_name}'."
+        except:
+            return False, "Exec failed."

velm/core/jurisprudence/vows/filesystem.py

@@ -0,0 +1,447 @@
+# Path: scaffold/core/jurisprudence/vows/filesystem.py
+# ----------------------------------------------------
+import hashlib
+import json
+import os
+import re
+import stat
+import time
+from pathlib import Path
+from typing import Tuple, Optional, Any, List
+
+from .base import BaseVowHandler
+from ....logger import Scribe
+
+try:
+    import yaml
+
+    YAML_AVAILABLE = True
+except ImportError:
+    YAML_AVAILABLE = False
+
+try:
+    import toml
+
+    TOML_AVAILABLE = True
+except ImportError:
+    TOML_AVAILABLE = False
+
+Logger = Scribe("FilesystemOracle")
+
+
+class FilesystemVowHandlers(BaseVowHandler):
+    """
+    =================================================================================
+    == THE ORACLE OF MATTER (V-Ω-OMNISCIENT-FS-GAZE-ASCENDED)                      ==
+    =================================================================================
+    LIF: 10,000,000,000,000,000
+
+    This artisan judges the physical reality of the Sanctum.
+    """
+
+    def _read_gnostic_content(self, path: Path) -> Optional[str]:
+        """
+        [THE DUAL GAZE]
+        Reads content from the Virtual Buffer if applicable, otherwise from Disk.
+        Returns None if reading fails (void).
+        """
+        # 1. Check Virtual Reality (Patch Buffer)
+        if self.target_file_path and path.resolve() == self.target_file_path.resolve():
+            if self.file_content_buffer is not None:
+                return self.file_content_buffer
+
+        # 2. Check Physical Reality (Disk)
+        if path.exists() and path.is_file():
+            try:
+                return path.read_text(encoding='utf-8', errors='replace')
+            except Exception:
+                return None
+        return None
+
+    def _check_virtual_existence(self, path_str: str) -> bool:
+        """
+        [THE FACULTY OF VIRTUAL PERCEPTION]
+        Checks if the file exists in the Architect's Plan (Virtual Manifest).
+        """
+        virtual_manifest: List[str] = getattr(
+            self.context, 'generated_manifest', []
+        ) or self.variables.get('generated_manifest', [])
+
+        if not virtual_manifest:
+            return False
+
+        target_clean = path_str.replace('\\', '/').strip('/')
+
+        if target_clean in virtual_manifest:
+            return True
+
+        for virtual_path in virtual_manifest:
+            if virtual_path.endswith(target_clean):
+                return True
+
+        return False
+
+    # =========================================================================
+    # == I. THE GAZE OF ONTOLOGY (EXISTENCE & TYPE)                          ==
+    # =========================================================================
+
+    def _vow_path_exists(self, path: str) -> Tuple[bool, str]:
+        """Asserts that a path (file or dir) manifests in reality or prophecy."""
+        target = self._resolve(path)
+
+        # Physical Check
+        if target.exists():
+            return True, f"Path '{path}' is physically manifest."
+
+        # Virtual Check
+        if self._check_virtual_existence(path):
+            return True, f"Path '{path}' is virtually manifest (in the Plan)."
+
+        return False, f"Path '{path}' is void in both Reality and Prophecy (Checked: {target})."
+
+    def _vow_path_not_exists(self, path: str) -> Tuple[bool, str]:
+        """Asserts that a path is void."""
+        target = self._resolve(path)
+
+        if target.exists():
+            return False, f"Path '{path}' exists physically (Heresy). Location: {target}"
+
+        if self._check_virtual_existence(path):
+            return False, f"Path '{path}' exists virtually (Heresy)."
+
+        return True, f"Path '{path}' is void."
+
+    def _vow_file_exists(self, path: str) -> Tuple[bool, str]:
+        """Asserts the entity is a scripture (File)."""
+        target = self._resolve(path)
+
+        if target.is_file():
+            return True, f"Scripture '{path}' is physically manifest."
+
+        if self._check_virtual_existence(path):
+            return True, f"Scripture '{path}' is virtually manifest."
+
+        return False, f"Scripture '{path}' is void. (Checked: {target})"
+
+    # Alias for backward compatibility
+    _vow_is_file = _vow_file_exists
+
+    def _vow_dir_exists(self, path: str) -> Tuple[bool, str]:
+        """Asserts the entity is a sanctum (Directory)."""
+        target = self._resolve(path)
+        # [THE DIAGNOSTIC FIX] Include resolved path in error message
+        return (
+            target.is_dir(),
+            f"Sanctum '{path}' is manifest."
+            if target.is_dir()
+            else f"Sanctum '{path}' is missing or not a directory. (Searched: {target})"
+        )
+
+    # Alias for backward compatibility
+    _vow_is_dir = _vow_dir_exists
+
+    def _vow_is_symlink(self, path: str) -> Tuple[bool, str]:
+        """Asserts the entity is a bridge (Symlink)."""
+        target = self._resolve(path)
+        return (
+            target.is_symlink(),
+            f"'{path}' is a symlink."
+            if target.is_symlink()
+            else f"'{path}' is solid matter."
+        )
+
+    def _vow_is_absolute_path(self, path: str) -> Tuple[bool, str]:
+        """Asserts the path string provided is absolute."""
+        p = Path(path)
+        return (
+            p.is_absolute(),
+            f"'{path}' is absolute."
+            if p.is_absolute()
+            else f"'{path}' is relative."
+        )
+
+    # =========================================================================
+    # == II. THE GAZE OF THE SOUL (TEXTUAL CONTENT)                          ==
+    # =========================================================================
+
+    def _vow_file_not_empty(self, path: str) -> Tuple[bool, str]:
+        content = self._read_gnostic_content(self._resolve(path))
+        if content is None:
+            if self._check_virtual_existence(path):
+                return True, f"'{path}' is virtually manifest (assumed non-empty)."
+            return False, f"'{path}' is void or unreadable."
+        return len(content) > 0, f"'{path}' contains {len(content)} chars."
+
+    def _vow_file_is_empty(self, path: str) -> Tuple[bool, str]:
+        content = self._read_gnostic_content(self._resolve(path))
+        if content is None:
+            return False, f"'{path}' is unreadable."
+        return len(content) == 0, f"'{path}' is empty."
+
+    def _vow_file_contains(self, path: str, text: str) -> Tuple[bool, str]:
+        content = self._read_gnostic_content(self._resolve(path))
+        if content is None:
+            return False, f"'{path}' is void."
+        if text in content:
+            return True, f"'{path}' contains the sacred phrase."
+        return False, f"'{path}' lacks the phrase '{text}'."
+
+    def _vow_file_not_contains(self, path: str, text: str) -> Tuple[bool, str]:
+        content = self._read_gnostic_content(self._resolve(path))
+        if content is None:
+            return False, f"'{path}' is void."
+        if text not in content:
+            return True, f"'{path}' is pure of '{text}'."
+        return False, f"'{path}' is tainted by '{text}'."
+
+    def _vow_file_matches_regex(self, path: str, pattern: str) -> Tuple[bool, str]:
+        content = self._read_gnostic_content(self._resolve(path))
+        if content is None:
+            return False, f"'{path}' is void."
+        try:
+            if re.search(pattern, content, re.MULTILINE):
+                return True, f"'{path}' matches pattern '{pattern}'."
+            return False, f"'{path}' does not match pattern '{pattern}'."
+        except re.error as e:
+            return False, f"Invalid Regex Heresy: {e}"
+
+    def _vow_file_not_matches_regex(self, path: str, pattern: str) -> Tuple[bool, str]:
+        content = self._read_gnostic_content(self._resolve(path))
+        if content is None:
+            return False, f"'{path}' is void."
+        try:
+            if not re.search(pattern, content, re.MULTILINE):
+                return True, f"'{path}' is free of pattern '{pattern}'."
+            return False, f"'{path}' is tainted by pattern '{pattern}'."
+        except re.error as e:
+            return False, f"Invalid Regex Heresy: {e}"
+
+    def _vow_file_starts_with(self, path: str, text: str) -> Tuple[bool, str]:
+        content = self._read_gnostic_content(self._resolve(path))
+        if content is None:
+            return False, f"'{path}' is void."
+        return content.startswith(text), f"'{path}' starts with '{text}'."
+
+    def _vow_file_ends_with(self, path: str, text: str) -> Tuple[bool, str]:
+        content = self._read_gnostic_content(self._resolve(path))
+        if content is None:
+            return False, f"'{path}' is void."
+        return content.strip().endswith(text), f"'{path}' ends with '{text}'."
+
+    # =========================================================================
+    # == III. THE GAZE OF STRUCTURE (JSON / YAML / TOML)                     ==
+    # =========================================================================
+
+    def _vow_is_valid_json(self, path: str) -> Tuple[bool, str]:
+        content = self._read_gnostic_content(self._resolve(path))
+        if content is None:
+            return False, "Unreadable."
+        try:
+            json.loads(content)
+            return True, f"'{path}' is valid JSON."
+        except json.JSONDecodeError as e:
+            return False, f"JSON Heresy in '{path}': {e}"
+
+    def _vow_is_valid_yaml(self, path: str) -> Tuple[bool, str]:
+        if not YAML_AVAILABLE:
+            return False, "PyYAML artisan missing."
+        content = self._read_gnostic_content(self._resolve(path))
+        if content is None:
+            return False, "Unreadable."
+        try:
+            yaml.safe_load(content)
+            return True, f"'{path}' is valid YAML."
+        except yaml.YAMLError as e:
+            return False, f"YAML Heresy in '{path}': {e}"
+
+    def _vow_is_valid_toml(self, path: str) -> Tuple[bool, str]:
+        if not TOML_AVAILABLE:
+            return False, "TOML artisan missing."
+        content = self._read_gnostic_content(self._resolve(path))
+        if content is None:
+            return False, "Unreadable."
+        try:
+            toml.loads(content)
+            return True, f"'{path}' is valid TOML."
+        except Exception as e:
+            return False, f"TOML Heresy in '{path}': {e}"
+
+    def _vow_json_key_equals(self, path: str, key_path: str, expected_value: str) -> Tuple[bool, str]:
+        content = self._read_gnostic_content(self._resolve(path))
+        if content is None:
+            return False, "Unreadable."
+        try:
+            data = json.loads(content)
+            val = self._extract_nested_key(data, key_path)
+            return str(val) == str(expected_value), f"JSON '{key_path}' == '{expected_value}'."
+        except KeyError:
+            return False, f"Key '{key_path}' not found in JSON."
+        except Exception as e:
+            return False, f"JSON Logic Paradox: {e}"
+
+    def _vow_yaml_key_equals(self, path: str, key_path: str, expected_value: str) -> Tuple[bool, str]:
+        if not YAML_AVAILABLE:
+            return False, "PyYAML missing."
+        content = self._read_gnostic_content(self._resolve(path))
+        if content is None:
+            return False, "Unreadable."
+        try:
+            data = yaml.safe_load(content)
+            val = self._extract_nested_key(data, key_path)
+            return str(val) == str(expected_value), f"YAML '{key_path}' == '{expected_value}'."
+        except KeyError:
+            return False, f"Key '{key_path}' not found in YAML."
+        except Exception as e:
+            return False, f"YAML Logic Paradox: {e}"
+
+    def _extract_nested_key(self, data: Any, key_path: str) -> Any:
+        current = data
+        for part in key_path.split('.'):
+            if isinstance(current, dict):
+                current = current.get(part)
+            elif isinstance(current, list) and part.isdigit():
+                current = current[int(part)]
+            else:
+                raise KeyError(f"Cannot traverse '{part}' in {type(current)}")
+            if current is None:
+                raise KeyError("Key is None")
+        return current
+
+    # =========================================================================
+    # == IV. THE GAZE OF METADATA (PERMISSIONS & OWNERSHIP)                  ==
+    # =========================================================================
+
+    def _vow_permissions_are(self, path: str, octal: str) -> Tuple[bool, str]:
+        target = self._resolve(path)
+        if not target.exists():
+            return False, "Path missing."
+        current = oct(target.stat().st_mode)[-3:]
+        return current == octal, f"Permissions are {current}."
+
+    def _vow_is_executable(self, path: str) -> Tuple[bool, str]:
+        target = self._resolve(path)
+        if not target.exists():
+            return False, "Path missing."
+        return os.access(target, os.X_OK), f"'{path}' is executable."
+
+    def _vow_is_writable(self, path: str) -> Tuple[bool, str]:
+        target = self._resolve(path)
+        return os.access(target, os.W_OK), f"'{path}' is writable."
+
+    def _vow_is_readable(self, path: str) -> Tuple[bool, str]:
+        target = self._resolve(path)
+        return os.access(target, os.R_OK), f"'{path}' is readable."
+
+    # =========================================================================
+    # == V. THE GAZE OF PHYSICALITY (SIZE & CRYPTOGRAPHY)                    ==
+    # =========================================================================
+
+    def _vow_file_size_gt(self, path: str, size_kb: str) -> Tuple[bool, str]:
+        target = self._resolve(path)
+        if not target.is_file():
+            return False, "Not a file."
+        try:
+            limit = float(size_kb) * 1024
+            actual = target.stat().st_size
+            return actual > limit, f"Size {actual}B > {limit}B."
+        except ValueError:
+            return False, "Invalid size parameter."
+
+    def _vow_file_size_lt(self, path: str, size_kb: str) -> Tuple[bool, str]:
+        target = self._resolve(path)
+        if not target.is_file():
+            return False, "Not a file."
+        try:
+            limit = float(size_kb) * 1024
+            actual = target.stat().st_size
+            return actual < limit, f"Size {actual}B < {limit}B."
+        except ValueError:
+            return False, "Invalid size parameter."
+
+    def _vow_checksum_matches(self, path: str, algorithm: str, expected_hash: str) -> Tuple[bool, str]:
+        target = self._resolve(path)
+        if not target.is_file():
+            return False, f"'{path}' is not a file."
+
+        try:
+            algo = getattr(hashlib, algorithm.lower())
+            hasher = algo()
+            with open(target, "rb") as f:
+                for chunk in iter(lambda: f.read(4096), b""):
+                    hasher.update(chunk)
+            actual_hash = hasher.hexdigest()
+
+            if actual_hash == expected_hash:
+                return True, f"{algorithm.upper()} Verified."
+            return False, f"Hash Mismatch. Expected {expected_hash}, found {actual_hash}."
+        except AttributeError:
+            return False, f"Unknown hash algorithm: '{algorithm}'"
+        except Exception as e:
+            return False, f"Hashing paradox: {e}"
+
+    # =========================================================================
+    # == VI. THE GAZE OF THE CHRONOMANCER (TIME)                             ==
+    # =========================================================================
+
+    def _vow_is_newer_than(self, path_a: str, path_b: str) -> Tuple[bool, str]:
+        t_a = self._resolve(path_a)
+        t_b = self._resolve(path_b)
+        if not t_a.exists():
+            return False, f"'{path_a}' missing."
+        if not t_b.exists():
+            return False, f"'{path_b}' missing."
+
+        return t_a.stat().st_mtime > t_b.stat().st_mtime, f"'{path_a}' is newer than '{path_b}'."
+
+    def _vow_modified_within(self, path: str, seconds: str) -> Tuple[bool, str]:
+        target = self._resolve(path)
+        if not target.exists():
+            return False, "Path missing."
+        try:
+            limit = float(seconds)
+            age = time.time() - target.stat().st_mtime
+            return age <= limit, f"Modified {age:.1f}s ago (limit {limit}s)."
+        except ValueError:
+            return False, "Invalid duration."
+
+    # =========================================================================
+    # == VII. THE GAZE OF THE SANCTUM (DIRECTORY HIERARCHY)                  ==
+    # =========================================================================
+
+    def _vow_dir_is_empty(self, path: str) -> Tuple[bool, str]:
+        target = self._resolve(path)
+        if not target.is_dir():
+            return False, "Not a directory."
+        is_empty = not any(target.iterdir())
+        return is_empty, f"Sanctum '{path}' is empty." if is_empty else f"Sanctum '{path}' is occupied."
+
+    def _vow_dir_not_empty(self, path: str) -> Tuple[bool, str]:
+        target = self._resolve(path)
+        if not target.is_dir():
+            return False, "Not a directory."
+        has_items = any(target.iterdir())
+        return has_items, f"Sanctum '{path}' is populated."
+
+    def _vow_dir_contains_file(self, path: str, filename: str) -> Tuple[bool, str]:
+        target = self._resolve(path)
+        if not target.is_dir():
+            return False, "Not a directory."
+        return (target / filename).exists(), f"Sanctum contains '{filename}'."
+
+    def _vow_dir_contains_glob(self, path: str, pattern: str) -> Tuple[bool, str]:
+        target = self._resolve(path)
+        if not target.is_dir():
+            return False, "Not a directory."
+        matches = list(target.glob(pattern))
+        return bool(matches), f"Found {len(matches)} match(es) for '{pattern}' in '{path}'."
+
+    def _vow_tree_contains_file(self, path: str, filename: str) -> Tuple[bool, str]:
+        target = self._resolve(path)
+        if not target.is_dir():
+            return False, "Not a directory."
+
+        try:
+            next(target.rglob(filename))
+            return True, f"Found '{filename}' deep within '{path}'."
+        except StopIteration:
+            return False, f"'{filename}' not found anywhere in '{path}' tree."

velm/core/jurisprudence/vows/git_vows.py

@@ -0,0 +1,63 @@
+import subprocess
+from typing import Tuple
+from .base import BaseVowHandler
+
+
+class GitVowHandlers(BaseVowHandler):
+    """
+    =============================================================================
+    == THE CHRONICLE OF VERSIONING (GIT)                                       ==
+    =============================================================================
+    Judges the state of the Source Control timeline.
+    """
+
+    def _run_git(self, args: list) -> Tuple[bool, str]:
+        """Internal helper for Git commands."""
+        if not (self.root / ".git").exists():
+            return False, "Not a git repository."
+        try:
+            res = subprocess.run(
+                ["git"] + args,
+                cwd=self.root,
+                capture_output=True,
+                text=True
+            )
+            return res.returncode == 0, res.stdout.strip()
+        except Exception as e:
+            return False, str(e)
+
+    def _vow_git_branch_is(self, branch_name: str) -> Tuple[bool, str]:
+        """Asserts the current HEAD is on a specific branch."""
+        ok, output = self._run_git(["rev-parse", "--abbrev-ref", "HEAD"])
+        if not ok: return False, output
+        return output == branch_name, f"Current branch is '{output}'."
+
+    def _vow_git_tag_exists(self, tag_name: str) -> Tuple[bool, str]:
+        """Asserts a specific tag exists in the local repo."""
+        ok, _ = self._run_git(["rev-parse", tag_name])
+        return ok, f"Tag '{tag_name}' {'exists' if ok else 'missing'}."
+
+    def _vow_git_is_clean(self) -> Tuple[bool, str]:
+        """Asserts there are no uncommitted changes."""
+        ok, output = self._run_git(["status", "--porcelain"])
+        if not ok: return False, "Git check failed."
+        return output == "", "Working tree is clean." if output == "" else "Working tree is dirty."
+
+    def _vow_git_remote_exists(self, remote_name: str) -> Tuple[bool, str]:
+        """Asserts a remote (e.g., 'origin') is configured."""
+        ok, output = self._run_git(["remote"])
+        remotes = output.splitlines()
+        return remote_name in remotes, f"Remote '{remote_name}' {'found' if remote_name in remotes else 'missing'}."
+
+    def _vow_git_has_commits(self) -> Tuple[bool, str]:
+        """Asserts the repository is not empty."""
+        ok, _ = self._run_git(["rev-parse", "HEAD"])
+        return ok, "Repository has history." if ok else "Repository is empty."
+
+    def _vow_git_ignore_check(self, path: str) -> Tuple[bool, str]:
+        """Asserts a path is ignored by .gitignore."""
+        ok, output = self._run_git(["check-ignore", path])
+        return ok, f"'{path}' is ignored." if ok else f"'{path}' is tracked."
+
+
+

velm/core/jurisprudence/vows/http_vows.py

@@ -0,0 +1,61 @@
+import json
+import urllib.request
+import urllib.error
+from typing import Tuple
+from .base import BaseVowHandler
+
+
+class HttpVowHandlers(BaseVowHandler):
+    """
+    =============================================================================
+    == THE ORACLE OF THE WEB (HTTP/API)                                        ==
+    =============================================================================
+    Judges the responsiveness and content of remote or local HTTP services.
+    Essential for validating `docker-compose` startups or API deployment.
+    """
+
+    def _make_request(self, url: str, method: str = "GET") -> Tuple[int, str, dict]:
+        """Internal helper."""
+        req = urllib.request.Request(url, method=method)
+        try:
+            with urllib.request.urlopen(req, timeout=5) as response:
+                body = response.read().decode('utf-8')
+                return response.status, body, response.headers
+        except urllib.error.HTTPError as e:
+            return e.code, e.read().decode('utf-8'), e.headers
+        except Exception as e:
+            return 0, str(e), {}
+
+    def _vow_http_status_is(self, url: str, status_code: str) -> Tuple[bool, str]:
+        """Asserts an endpoint returns a specific status code (e.g., 200)."""
+        code, _, _ = self._make_request(url)
+        target = int(status_code)
+        return code == target, f"URL returned {code} (Expected {target})."
+
+    def _vow_http_body_contains(self, url: str, text: str) -> Tuple[bool, str]:
+        """Asserts the response body contains a string."""
+        code, body, _ = self._make_request(url)
+        if code == 0: return False, f"Connection failed: {body}"
+        return text in body, f"Response {'contains' if text in body else 'lacks'} '{text}'."
+
+    def _vow_http_is_json(self, url: str) -> Tuple[bool, str]:
+        """Asserts the response is valid JSON."""
+        code, body, _ = self._make_request(url)
+        if code == 0: return False, "Connection failed."
+        try:
+            json.loads(body)
+            return True, "Response is valid JSON."
+        except:
+            return False, "Response is not JSON."
+
+    def _vow_http_header_equals(self, url: str, header: str, value: str) -> Tuple[bool, str]:
+        """Asserts a specific header matches."""
+        code, _, headers = self._make_request(url)
+        if code == 0: return False, "Connection failed."
+
+        actual = headers.get(header, "")
+        return actual == value, f"Header '{header}' is '{actual}'."
+
+    def _vow_http_is_https(self, url: str) -> Tuple[bool, str]:
+        """Asserts the URL uses a secure transport."""
+        return url.startswith("https://"), f"URL scheme is {'https' if url.startswith('https') else 'insecure'}."

velm/core/jurisprudence/vows/meta.py

@@ -0,0 +1,43 @@
+import subprocess
+from typing import Tuple
+from .base import BaseVowHandler
+from rich.prompt import Confirm
+
+
+class MetaVowHandlers(BaseVowHandler):
+    """
+    =============================================================================
+    == THE ORACLE OF LOGIC (VARIABLES, GIT, & TIME)                            ==
+    =============================================================================
+    Judges internal state, git history, and user intent.
+    """
+
+    # --- VARIABLE LOGIC ---
+    def _vow_variable_equals(self, name: str, value: str) -> Tuple[bool, str]:
+        actual = str(self.variables.get(name, ""))
+        return actual == value, f"$$ {name} == '{value}'."
+
+    def _vow_is_truthy(self, name: str) -> Tuple[bool, str]:
+        val = self.variables.get(name)
+        is_true = bool(val) and str(val).lower() not in ('false', '0', 'no', 'off', 'none')
+        return is_true, f"$$ {name} is Truthy."
+
+    # --- GIT LOGIC ---
+    def _vow_git_clean(self) -> Tuple[bool, str]:
+        if not (self.root / ".git").exists(): return False, "Not a git repo."
+        try:
+            res = subprocess.run(["git", "status", "--porcelain"], cwd=self.root, capture_output=True, text=True)
+            return not res.stdout.strip(), "Git working tree is clean."
+        except:
+            return False, "Git status check failed."
+
+    def _vow_confirm(self, question: str) -> Tuple[bool, str]:
+        """Pauses for the Architect's confirmation."""
+        # In non-interactive contexts (CI), we might default to True or False based on flags.
+        # For now, we assume interactive or fail.
+        import sys
+        if not sys.stdout.isatty():
+            return True, "Auto-confirmed (Non-interactive)."
+
+        choice = Confirm.ask(f"[bold yellow]Vow Required:[/bold yellow] {question}")
+        return choice, "Architect confirmed." if choice else "Architect denied."