merge: sync upstream profanity-im/profanity

Sync with upstream profanity-im/profanity.

Major upstream changes incorporated:

Memory management
  - Replace malloc+memset with g_new0 throughout codebase
  - Adopt auto_gchar / auto_gcharv / auto_gerror / auto_jid cleanup macros
  - Replace free() with g_free() for GAlloc'd memory

Editor rewrite
  - Remove pthread-based async editor; use GChildWatch callback API
  - New launch_editor(initial_content, callback, user_data) interface
  - Proper signal handling (SIGINT, SIGTSTP, SIGPIPE reset in child)
  - ui_suspend()/ui_resume() integration for TTY management

OMEMO improvements
  - Dual backend support: libsignal-protocol-c and libomemo-c
  - Proper pre-key removal after use (XEP-0384 compliance)
  - Automatic pre-key regeneration when store drops below threshold
  - New functions: omemo_is_device_active(), omemo_is_jid_trusted()
  - omemo_get_jid_untrusted_fingerprints() for better error messages
  - Fingerprint notifications on new device identity discovery
  - Deterministic pre-key ID generation tracking max_pre_key_id
  - omemo_trust_changed() UI updates on trust state changes

JID validation
  - RFC 6122-compliant validation in jid_is_valid()
  - Character-level checks (RFC 6122 forbidden chars: & ' / : < > @)
  - Length limits: 1023 per component, 3071 total
  - New jid_is_valid_user_jid() for user vs. service JID distinction

Database
  - Schema migration v3: UNIQUE constraint on archive_id for deduplication
  - Triggers for corrected message tracking (replaces_db_id / replaced_by_db_id)
  - db_history_result_t return type, _truncate_datetime_suffix()

UI / console
  - win_warn_needed() / win_warn_sent() warning deduplication hash table
  - PAD_MIN_HEIGHT dynamic pad sizing with PAD_THRESHOLD auto-cleanup
  - Spellcheck integration in input field with Unicode word detection
  - cons_spellcheck_setting() for /settings ui output
  - /[command]? shortcut for command help

Account config
  - Account name sanitization for GKeyFile special chars ([ ] = # \n \r)
  - Replace popen() with g_spawn_sync() for eval_password
  - TLS policy: add "direct" option alongside legacy

Connection
  - Port validation with g_assert (0–65535)
  - SHA-256 certificate fingerprint support (XMPP_CERT_PUBKEY_FINGERPRINT_SHA256)
  - "direct" TLS policy alias for legacy SSL

Common utilities
  - str_xml_sanitize() for XML 1.0 illegal character removal
  - string_matches_one_of() with formatted error messages
  - valid_tls_policy_option() helper
  - prof_date_time_format_iso8601() utility
  - Improved strip_arg_quotes() with backslash unescaping
  - prof_occurrences() uses g_slist_prepend + reverse for performance

PGP / OX
  - Proper GPGME resource cleanup with goto-cleanup pattern
  - g_string_free(xmppuri) leak fix in _ox_key_lookup

CSV export
  - Use GString + g_file_set_contents instead of raw write() syscalls

Tests
  - Restructured into subdirectories: command/, config/, xmpp/, ui/, omemo/, otr/, pgp/
  - New test_cmd_ac.c for autocompleter unit tests
  - Updated stubs for new UI suspend/resume functions

License headers
  - Migrate to SPDX-3.0 identifiers (GPL-3.0-or-later WITH OpenSSL-exception)

────────────────────────────────────────────────────
cproof-specific preservations:

  - XEP-0308 LMC: replace_id ?: id logic in message/stanza/omemo
  - Force encryption: cmd_force_encryption, test_forced_encryption
  - CWE-134: format string protection (cons_show("%s", ...))
  - y_start_pos-based paging in window.c
  - db_history_result_t return type, _truncate_datetime_suffix()

Merge-time fixes:

  - common.c: format-security (-Werror) — cons_show(errmsg) → cons_show("%s", errmsg)
  - database.c: null-deref guard — !msg->timestamp → msg && !msg->timestamp
  - console.c: implicit size_t → int cast — (int)(maxlen + 1)
  - tlscerts.c: %d for size_t — %zu

Build system:
  - Kept autotools (Makefile.am, configure.ac); upstream uses Meson
  - Restored deleted files: bootstrap.sh, autogen.sh, ax_valgrind_check.m4, configure-debug
  - Updated Makefile.am test paths for subdirectory structure
  - Added test_cmd_ac, test_forced_encryption to test sources

Functional tests:
  - Use cproof version; upstream requires stbbr_for_xmlns from updated stabber
  - Not yet available in devs/stabber fork

Closes #64

Merge author: jabber.developer2
Commits authors:
 Michael Vetter <jubalh@iodoru.org>
& Steffen Jaeckel <s@jaeckel.eu>

scripts/README.md

@@ -0,0 +1,35 @@
+# Scripts
+
+This directory contains various scripts used for development, CI, and maintenance.
+
+## `lint-and-test.sh`
+Central validation script mainly for local development.
+
+- **Purpose:** Runs spelling checks, code formatting, and unit testing.
+- **Usage:** `./scripts/lint-and-test.sh [options]`
+- **Options:**
+  - `--fix-formatting`: Automatically apply `clang-format` fixes.
+  - `--tests`: Run unit tests using Meson.
+  - `--hook`: Run in "hook mode" (checks only staged files).
+  - `--install`: Install the script as a git `pre-commit` hook.
+
+## `build-configuration-matrix.sh`
+Exhaustive build configuration matrix testing. It ensures that Profanity compiles and passes unit tests across a variety of feature configurations for Meson.
+
+- **Purpose:** Verifies architectural compatibility by testing many combinations of build flags.
+- **Usage:** `./scripts/build-configuration-matrix.sh [extra-args]`
+- **Extra Arguments:** Any arguments are forwarded directly to the configuration command (`meson setup`).
+- **Environment:** Primarily used in CI (GitHub Actions), but can be run locally to verify all configurations.
+
+## `changelog-helper.py`
+Generates a sorted changelog from git commits since the last tag.
+
+- **Purpose:** Automates the creation of release notes by parsing Conventional Commit messages.
+- **Usage:** `python3 scripts/changelog-helper.py [--pr]`
+- **Options:** Use `--pr` to append Pull Request numbers to each entry.
+
+## `check-new-xeps.py`
+Checks for updates to XMPP Extension Protocols (XEPs).
+
+- **Purpose:** Compares the versions of XEPs implemented in Profanity (tracked in `profanity.doap`) against the latest versions available at `xmpp.org`.
+- **Usage:** `python3 scripts/check-new-xeps.py`

scripts/build-configuration-matrix.sh

@@ -0,0 +1,113 @@
+#!/usr/bin/env bash
+
+# Exhaustive build configuration matrix testing for Profanity
+
+set -e
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+log_content() {
+    echo
+    if [ -f "$1" ]; then
+        echo "Content of $1:"
+        cat "$1"
+    else
+        echo "Log file $1 not found."
+    fi
+}
+
+error_handler() {
+    ERR_CODE=$?
+    echo -e "${RED}Error ${ERR_CODE} with command '${BASH_COMMAND}' on line ${BASH_LINENO[0]}. Exiting.${NC}"
+
+    for log in build_run/meson-logs/testlog.txt build_valgrind/meson-logs/testlog.txt; do
+        if [ -f "$log" ]; then
+            echo "--- Meson Test Log ($log) ---"
+            cat "$log"
+        fi
+    done
+    exit ${ERR_CODE}
+}
+
+trap error_handler ERR
+
+num_cores() {
+    nproc \
+        || sysctl -n hw.ncpu \
+        || getconf _NPROCESSORS_ONLN 2>/dev/null \
+        || echo 2
+}
+
+usage() {
+    echo "Usage: $0 [extra-args]"
+    echo ""
+    echo "Run exhaustive build matrix tests."
+    echo ""
+    echo "Extra arguments are passed directly to: meson setup [extra-args]"
+    exit 0
+}
+
+if [[ "$1" == "--help" || "$1" == "-h" ]]; then
+    usage
+fi
+
+# Compatibility with old script that took autotools|meson as first arg
+if [[ "$1" == "meson" ]]; then
+    shift
+elif [[ "$1" == "autotools" ]]; then
+    echo -e "${RED}Error: Autotools is no longer supported.${NC}"
+    exit 1
+fi
+
+ARCH="$(uname | tr '[:upper:]' '[:lower:]')"
+EXTRA_ARGS="$*"
+
+# Build Matrix
+echo -e "${YELLOW}---> Starting build matrix...${NC}"
+
+tests=(
+    "-Dnotifications=enabled -Dicons-and-clipboard=enabled -Dotr=enabled -Dpgp=enabled -Domemo=enabled -Dc-plugins=enabled -Dpython-plugins=enabled -Dxscreensaver=enabled -Domemo-qrcode=enabled -Dgdk-pixbuf=enabled"
+    ""
+    "-Dnotifications=disabled"
+    "-Dicons-and-clipboard=disabled"
+    "-Dotr=disabled"
+    "-Dpgp=disabled"
+    "-Domemo=disabled -Domemo-qrcode=disabled"
+    "-Dpgp=disabled -Dotr=disabled"
+    "-Dpgp=disabled -Dotr=disabled -Domemo=disabled"
+    "-Dpython-plugins=disabled"
+    "-Dc-plugins=disabled"
+    "-Dc-plugins=disabled -Dpython-plugins=disabled"
+    "-Dxscreensaver=disabled"
+    "-Dgdk-pixbuf=disabled"
+)
+
+BACKEND_OPT=""
+if [ -n "${OMEMO_BACKEND}" ]; then
+    BACKEND_OPT="-Domemo-backend=${OMEMO_BACKEND}"
+fi
+
+# Valgrind check (Linux only)
+if [[ "$ARCH" == linux* ]]; then
+    echo -e "${YELLOW}--> Running Valgrind check with full features ${BACKEND_OPT} ${EXTRA_ARGS}${NC}"
+    rm -rf build_valgrind
+    meson setup build_valgrind ${tests[0]} ${BACKEND_OPT} -Dtests=true -Db_sanitize=undefined ${EXTRA_ARGS}
+    meson compile -C build_valgrind
+    meson test -C build_valgrind "unit tests" --print-errorlogs --wrap=valgrind || echo "Valgrind issues detected"
+    rm -rf build_valgrind
+fi
+
+for features in "${tests[@]}"
+do
+    echo -e "${YELLOW}--> Building with: ${features} ${BACKEND_OPT} ${EXTRA_ARGS}${NC}"
+    rm -rf build_run
+    meson setup build_run ${features} ${BACKEND_OPT} -Dtests=true ${EXTRA_ARGS}
+    meson compile -C build_run
+    meson test -C build_run "unit tests" --print-errorlogs
+    ./build_run/profanity -v
+done
+
+echo -e "${GREEN}Build configuration matrix testing successful!${NC}"

scripts/changelog-helper.py

@@ -0,0 +1,165 @@
+#!/usr/bin/env python3
+
+# Since we use Conventional Commits
+# we can now create our Changelog semi-automatically
+
+import subprocess
+import sys
+import re
+import argparse
+from collections import defaultdict
+
+# Configuration for sections and their order
+SECTION_CONFIG = [
+    ("fix", "Bug Fixes"),
+    ("feat", "Features"),
+    ("build", "Build System"),
+    ("ci", "CI"),
+    ("docs", "Documentation"),
+    ("perf", "Performance Improvements"),
+    ("refactor", "Refactorings"),
+    ("cleanup", "Cleanup"),
+    ("style", "Style"),
+    ("tests", "Tests"),
+    ("chore", "Chores"),
+]
+SECTIONS = dict(SECTION_CONFIG)
+TYPE_ORDER = [t for t, _ in SECTION_CONFIG]
+
+CORRECTIONS = {
+    "ests": "tests",
+    "wleanup": "cleanup",
+}
+
+def git_run(args):
+    """Run a git command and return stripped output lines."""
+    try:
+        result = subprocess.run(["git"] + args, capture_output=True, text=True, check=True)
+        return [line for line in result.stdout.strip().split('\n') if line]
+    except subprocess.CalledProcessError:
+        return []
+
+def get_last_tag():
+    output = git_run(["describe", "--tags", "--abbrev=0"])
+    return output[0] if output else None
+
+def get_commits(revision_range):
+    """Get list of (hash, subject) tuples."""
+    lines = git_run(["log", revision_range, "--format=%H %s"])
+    commits = []
+    for line in lines:
+        parts = line.split(' ', 1)
+        if len(parts) == 2:
+            commits.append(parts)
+    return commits
+
+def get_pr_mappings(revision_range):
+    """Map commit hashes to PR numbers found in merge commits."""
+    merge_commits = git_run(["log", revision_range, "--merges", "--format=%H %s"])
+    pr_map = {}
+    pr_re = re.compile(r'Merge pull request #(\d+)')
+
+    for line in merge_commits:
+        parts = line.split(' ', 1)
+        if len(parts) < 2:
+            continue
+        m_hash, m_subject = parts
+        match = pr_re.search(m_subject)
+        if match:
+            pr_num = match.group(1)
+            # Find all commits that are part of this merge branch
+            branch_commits = git_run(["rev-list", f"{m_hash}^1..{m_hash}^2"])
+            for b_hash in branch_commits:
+                pr_map[b_hash] = pr_num
+    return pr_map
+
+def get_contributors(revision_range):
+    """Get sorted list of all unique contributors."""
+    cmd = ["log", revision_range, "--format=%an%n%(trailers:key=Co-authored-by,valueonly=true)"]
+    output = git_run(cmd)
+    
+    contributors = set()
+    for line in output:
+        # Remove email part if present: "Name <email@example.com>" -> "Name"
+        name = line.split('<')[0].strip()
+        if name:
+            contributors.add(name)
+    
+    return sorted(list(contributors))
+
+def format_description(description):
+    """Capitalize first letter of description."""
+    description = description.strip()
+    if description and description[0].islower():
+        return description[0].upper() + description[1:]
+    return description
+
+def main():
+    parser = argparse.ArgumentParser(description="Generate a sorted changelog from git commits.")
+    parser.add_argument("--pr", action="store_true", help="Append PR number to each commit.")
+    args = parser.parse_args()
+
+    last_tag = get_last_tag()
+    if not last_tag:
+        print("No tags found in the repository.", file=sys.stderr)
+    
+    revision_range = f"{last_tag}..HEAD" if last_tag else "HEAD"
+    
+    commits = get_commits(revision_range)
+    if not commits:
+        print(f"No commits found since {last_tag if last_tag else 'the beginning'}.")
+        return
+
+    pr_map = get_pr_mappings(revision_range) if args.pr else {}
+
+    # Conventional Commit regex: type(scope): description
+    commit_re = re.compile(r'^(\w+)(?:\(([^)]+)\))?:\s*(.*)$')
+
+    grouped = defaultdict(list)
+    others = []
+
+    for c_hash, c_subject in commits:
+        # Skip merge commits in the output
+        if c_subject.startswith(("Merge pull request", "Merge branch")):
+            continue
+
+        pr_suffix = f" (#{pr_map[c_hash]})" if c_hash in pr_map else ""
+        match = commit_re.match(c_subject)
+
+        if match:
+            ctype = match.group(1).lower()
+            ctype = CORRECTIONS.get(ctype, ctype)
+            description = format_description(match.group(3))
+            grouped[ctype].append(f"{description}{pr_suffix}")
+        else:
+            others.append(f"{c_subject}{pr_suffix}")
+
+    # Output sections in ordered priority
+    all_types = TYPE_ORDER + sorted([t for t in grouped if t not in TYPE_ORDER])
+    first = True
+    for ctype in all_types:
+        if ctype in grouped:
+            if not first:
+                print()
+            section_name = SECTIONS.get(ctype, ctype.capitalize())
+            print(f"{section_name}:")
+            for msg in sorted(grouped[ctype]):
+                print(f"- {msg}")
+            first = False
+
+    if others:
+        if not first:
+            print()
+        print("Others:")
+        for msg in sorted(others):
+            print(f"- {msg}")
+
+    # Contributors section
+    contributors = get_contributors(revision_range)
+    if contributors:
+        print("\nContributors:")
+        for i, name in enumerate(contributors, 1):
+            print(f"{i}. {name}")
+
+if __name__ == "__main__":
+    main()

scripts/check-new-xeps.py

@@ -0,0 +1,136 @@
+#!/usr/bin/env python3
+import os
+import re
+import sys
+import urllib.request
+import xml.etree.ElementTree as ET
+from itertools import zip_longest
+from typing import Dict, List, Optional
+
+
+# Namespaces in DOAP
+NS = {
+    "rdf": "http://www.w3.org/1999/02/22-rdf-syntax-ns#",
+    "foaf": "http://xmlns.com/foaf/0.1/",
+    "doap": "http://usefulinc.com/ns/doap#",
+    "xmpp": "https://linkmauve.fr/ns/xmpp-doap#",
+    "schema": "https://schema.org/",
+}
+
+
+def compare_versions(v1: str, v2: str) -> int:
+    """
+    Compare two version strings.
+    Returns 1 if v2 > v1, -1 if v1 > v2, 0 if equal.
+    """
+    def parse_v(v: str) -> List[int]:
+        return [int(x) for x in re.split(r"[^0-9]+", v) if x]
+
+    parts1 = parse_v(v1)
+    parts2 = parse_v(v2)
+
+    for p1, p2 in zip_longest(parts1, parts2, fillvalue=0):
+        if p2 > p1:
+            return 1
+        if p1 > p2:
+            return -1
+    return 0
+
+
+def find_doap() -> Optional[str]:
+    """Try to find profanity.doap in current or parent directory."""
+    candidates = ["profanity.doap", "../profanity.doap"]
+    for c in candidates:
+        if os.path.exists(c):
+            return c
+    return None
+
+
+def get_implemented_xeps(doap_path: str) -> Dict[str, str]:
+    """Parse DOAP file and return a map of XEP number to version."""
+    implemented_xeps: Dict[str, str] = {}
+    try:
+        tree = ET.parse(doap_path)
+        root = tree.getroot()
+
+        for implements in root.findall(".//doap:implements", NS):
+            supported_xep = implements.find(".//xmpp:SupportedXep", NS)
+            if supported_xep is not None:
+                xep_res = supported_xep.find(".//xmpp:xep", NS)
+                version_elem = supported_xep.find(".//xmpp:version", NS)
+
+                if xep_res is not None and version_elem is not None:
+                    resource = xep_res.attrib.get(f"{{{NS['rdf']}}}resource", "")
+                    match = re.search(r"xep-(\d+)\.html", resource)
+                    if match:
+                        xep_num = match.group(1)
+                        current_version = version_elem.text.strip() if version_elem.text else ""
+                        implemented_xeps[xep_num] = current_version
+    except (ET.ParseError, PermissionError) as e:
+        print(f"Error reading {doap_path}: {e}")
+        sys.exit(1)
+
+    return implemented_xeps
+
+
+def check_xeps() -> None:
+    """Main logic for checking XEP updates."""
+    doap_path = find_doap()
+    if not doap_path:
+        print("Error: Could not find DOAP file.")
+        sys.exit(1)
+
+    implemented_xeps = get_implemented_xeps(doap_path)
+    if not implemented_xeps:
+        print("No XEPs found in DOAP file.")
+        return
+
+    print(f"XEPs tracked: {len(implemented_xeps)}")
+
+    try:
+        url = "https://xmpp.org/extensions/xeplist.xml"
+        with urllib.request.urlopen(url, timeout=15) as response:
+            xeplist_xml = response.read()
+    except Exception as e:
+        print(f"Error fetching xeplist.xml: {e}")
+        return
+
+    try:
+        xeplist_tree = ET.fromstring(xeplist_xml)
+    except ET.ParseError as e:
+        print(f"Error parsing xeplist.xml: {e}")
+        return
+
+    print(f"\n{'XEP':<10} | {'Name':<35} | {'Ours':<8} | {'Latest':<8}")
+    print("-" * 80)
+
+    updates_found = 0
+    for xep_node in xeplist_tree.findall("xep"):
+        number_node = xep_node.find("number")
+        title_node = xep_node.find("title")
+        last_revision_node = xep_node.find("last-revision")
+
+        if number_node is None or title_node is None or last_revision_node is None:
+            continue
+
+        number = (number_node.text or "0").zfill(4)
+        name = title_node.text or "Unknown"
+        version_node = last_revision_node.find("version")
+
+        if version_node is None or version_node.text is None:
+            continue
+
+        latest_version = version_node.text
+
+        if number in implemented_xeps:
+            old_version = implemented_xeps[number]
+            if compare_versions(old_version, latest_version) > 0:
+                print(f"XEP-{number:<4} | {name[:35]:<35} | {old_version:<8} | {latest_version:<8}")
+                updates_found += 1
+
+    if updates_found == 0:
+        print("All tracked XEPs are up to date.")
+
+
+if __name__ == "__main__":
+    check_xeps()

scripts/lint-and-test.sh

@@ -0,0 +1,138 @@
+#!/usr/bin/env bash
+
+# Central linting and testing script for Profanity
+
+set -e
+
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+NC='\033[0m'
+
+# Go to project root
+cd "$(dirname "$0")/.."
+
+usage() {
+    echo "Usage: $0 [options]"
+    echo ""
+    echo "Description:"
+    echo "  Code quality checks (spelling, formatting, and unit tests)."
+    echo "  Works with meson and can be used as a git"
+    echo "  pre-commit hook."
+    echo ""
+    echo "Options:"
+    echo "  --fix-formatting Apply formatting fixes (default is check only)"
+    echo "  --no-format      Skip the formatting check/fix entirely. Use this if your local"
+    echo "                   clang-format version produces different results than the CI."
+    echo "                   Can also be set via SKIP_FORMAT=1 environment variable."
+    echo "  --tests          Run unit tests using Meson (meson test)"
+    echo "  --hook           Git hook mode: Checks only staged files for spelling and"
+    echo "                   formatting. Does not run tests to ensure fast commits."
+    echo "  --install        Install this script as a git pre-commit hook"
+    echo "  --help           Show this help message"
+}
+
+run_tests() {
+    local system=$1
+    echo -e "${YELLOW}---> Running unit tests...${NC}"
+    
+    if [ "$system" == "meson" ]; then
+        echo "Using Meson..."
+        # Uses build_run
+        meson test -C build_run "unit tests"
+    fi
+}
+
+run_format() {
+    local mode=$1
+    local hook_mode=$2
+    local skip=$3
+    local files
+
+    if [ "$skip" = true ]; then
+        echo -e "${YELLOW}---> Skipping formatting check.${NC}"
+        return
+    fi
+
+    if [ "$hook_mode" = true ]; then
+        echo -e "${YELLOW}---> Checking staged files for formatting...${NC}"
+        # Only added/modified C files
+        files=$(git diff --cached --name-only --diff-filter=ACMR | grep -E "\.(c|h)$" || true)
+    else
+        echo -e "${YELLOW}---> Checking all files for formatting...${NC}"
+        files=$(find src tests -name "*.[ch]" || true)
+    fi
+
+    if [ -z "$files" ]; then
+        echo "No C files to check."
+        return
+    fi
+
+    if [ "$mode" = "fix" ]; then
+        clang-format -i $files
+        echo -e "${GREEN}Formatting applied.${NC}"
+    else
+        # --Werror makes it return non-zero on diff
+        if ! clang-format --dry-run --Werror $files; then
+            echo -e "${RED}Error: Style violations found. Run '$0 --fix-formatting' to resolve.${NC}"
+            echo -e "${RED}If this is due to a clang-format version mismatch, use --no-format or SKIP_FORMAT=1.${NC}"
+            exit 1
+        fi
+        echo -e "${GREEN}Style check passed.${NC}"
+    fi
+}
+
+run_spell() {
+    echo -e "${YELLOW}---> Running spell check...${NC}"
+    if command -v codespell >/dev/null 2>&1; then
+        codespell
+        echo -e "${GREEN}Spell check passed.${NC}"
+    else
+        echo -e "${YELLOW}Warning: codespell not found, skipping.${NC}"
+    fi
+}
+
+MODE="check"
+BUILD_SYSTEM="none"
+HOOK=false
+
+# Support environment variable override
+if [[ "$SKIP_FORMAT" == "1" || "$SKIP_FORMAT" == "true" ]]; then
+    INTERNAL_SKIP_FORMAT=true
+else
+    INTERNAL_SKIP_FORMAT=false
+fi
+
+while [[ "$#" -gt 0 ]]; do
+    case $1 in
+        --fix-formatting) MODE="fix" ;;
+        --no-format) INTERNAL_SKIP_FORMAT=true ;;
+        --tests) BUILD_SYSTEM="meson" ;;
+        --hook) HOOK=true ;;
+        --install)
+            echo "Installing pre-commit hook..."
+            mkdir -p .git/hooks
+            echo "#!/usr/bin/env bash" > .git/hooks/pre-commit
+            echo "./scripts/lint-and-test.sh --hook" >> .git/hooks/pre-commit
+            chmod +x .git/hooks/pre-commit
+            echo "Hook installed."
+            exit 0
+            ;;
+        --help) usage; exit 0 ;;
+        *) echo "Unknown parameter: $1"; usage; exit 1 ;;
+    esac
+    shift
+done
+
+# Always run spell check
+run_spell
+
+# Run format check unless skipped
+run_format "$MODE" "$HOOK" "$INTERNAL_SKIP_FORMAT"
+
+# Run tests if a build system was specified
+if [ "$BUILD_SYSTEM" != "none" ]; then
+    run_tests "$BUILD_SYSTEM"
+fi
+
+echo -e "${GREEN}Validation successful!${NC}"