gluekit 1.0.1.dev1__py3-none-any.whl

gluekit/commands/init.py

@@ -0,0 +1,798 @@
+from __future__ import annotations
+
+import configparser
+import csv
+import os
+import re
+import shlex
+from collections.abc import Mapping
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Optional
+
+import typer
+from rapidfuzz import fuzz
+from slugify import slugify
+
+from ..job_mgmt.glue_jobs import (
+    download_glue_job_files,
+    get_glue_job_config,
+    list_glue_jobs,
+)
+
+from .constants import GLUE_SET_FILE
+from .helpers import (
+    _examples_epilog,
+    _get_checked_out_jobs,
+    _load_glue_set_store,
+    _resolve_checkout_job_name,
+    _save_checked_out_jobs,
+    _save_glue_set_store,
+    _set_saved_scope,
+)
+from ..cli import app
+
+
+S3_URI_PATTERN = re.compile(r"^s3://(?P<bucket>[^/\s,]+)(?:/(?P<key>[^\s,]*))?$")
+S3_DETECTION_ROOTS = {
+    "Command",
+    "DefaultArguments",
+    "NonOverridableArguments",
+}
+S3_SOURCE_CONTROL_KEYS = {
+    "AdditionalPythonFiles",
+    "ExtraPyFiles",
+    "AdditionalFiles",
+    "ExtraFiles",
+}
+
+
+@dataclass(frozen=True)
+class S3UriRecord:
+    field_path: str
+    token_index: int
+    uri: str
+    bucket: str
+    key: str
+    field_value: Any
+
+    @property
+    def identity(self) -> tuple[str, int]:
+        return self.field_path, self.token_index
+
+
+@dataclass(frozen=True)
+class S3DetectionResult:
+    params: dict[str, Any]
+    skipped: list[str]
+    candidates: dict[str, list[tuple[str, int]]]
+
+
+def _aws_profiles_from_config(config_path: Path) -> list[str]:
+    parser = configparser.ConfigParser()
+    if not config_path.exists():
+        return []
+    parser.read(config_path)
+    profiles: list[str] = []
+    for section in parser.sections():
+        if section == "default":
+            profiles.append("default")
+        elif section.startswith("profile "):
+            profiles.append(section.removeprefix("profile ").strip())
+    return sorted({profile for profile in profiles if profile})
+
+
+def _save_profile_param(
+    *,
+    profile: str,
+    job_name: str,
+    key: str,
+    value: Any,
+) -> None:
+    _set_saved_scope({key: value}, job_name, False, profile=profile)
+
+
+def _parse_s3_uri(value: str) -> tuple[str, str] | None:
+    match = S3_URI_PATTERN.match(value.strip())
+    if not match:
+        return None
+    return match.group("bucket"), match.group("key") or ""
+
+
+def _parse_csv_tokens(value: str) -> list[str]:
+    try:
+        return [item.strip() for item in next(csv.reader([value]))]
+    except csv.Error:
+        return [value.strip()]
+
+
+def _append_s3_records_from_string(
+    records: list[S3UriRecord],
+    *,
+    field_path: str,
+    field_value: str,
+) -> None:
+    tokens = _parse_csv_tokens(field_value)
+    if not tokens:
+        tokens = [field_value.strip()]
+    for index, token in enumerate(tokens):
+        parsed = _parse_s3_uri(token)
+        if not parsed:
+            continue
+        bucket, key = parsed
+        records.append(
+            S3UriRecord(
+                field_path=field_path,
+                token_index=index,
+                uri=token,
+                bucket=bucket,
+                key=key,
+                field_value=field_value,
+            )
+        )
+
+
+def _collect_s3_uri_records_from_value(
+    value: Any,
+    *,
+    field_path: str,
+    records: list[S3UriRecord],
+) -> None:
+    if isinstance(value, str):
+        _append_s3_records_from_string(
+            records, field_path=field_path, field_value=value
+        )
+        return
+    if isinstance(value, dict):
+        for key, child in value.items():
+            _collect_s3_uri_records_from_value(
+                child,
+                field_path=f"{field_path}.{key}",
+                records=records,
+            )
+        return
+    if isinstance(value, list):
+        for index, child in enumerate(value):
+            _collect_s3_uri_records_from_value(
+                child,
+                field_path=f"{field_path}[{index}]",
+                records=records,
+            )
+
+
+def collect_config_s3_uri_records(config_data: dict[str, Any]) -> list[S3UriRecord]:
+    records: list[S3UriRecord] = []
+    for root in S3_DETECTION_ROOTS:
+        value = config_data.get(root)
+        if value is not None:
+            _collect_s3_uri_records_from_value(
+                value,
+                field_path=root,
+                records=records,
+            )
+
+    source_control = config_data.get("SourceControlDetails", {})
+    if isinstance(source_control, dict):
+        for key in S3_SOURCE_CONTROL_KEYS:
+            value = source_control.get(key)
+            if value is not None:
+                _collect_s3_uri_records_from_value(
+                    value,
+                    field_path=f"SourceControlDetails.{key}",
+                    records=records,
+                )
+    return records
+
+
+def detect_profile_s3_params(
+    *,
+    baseline_config: dict[str, Any],
+    target_config: dict[str, Any],
+    match_threshold: int,
+) -> S3DetectionResult:
+    baseline_records = collect_config_s3_uri_records(baseline_config)
+    target_records = collect_config_s3_uri_records(target_config)
+    target_by_identity = {record.identity: record for record in target_records}
+    target_by_field_path: dict[str, list[S3UriRecord]] = {}
+    for record in target_records:
+        target_by_field_path.setdefault(record.field_path, []).append(record)
+
+    params: dict[str, Any] = {}
+    skipped: list[str] = []
+    candidate_summary: dict[str, list[tuple[str, int]]] = {}
+
+    for baseline_record in baseline_records:
+        target_record = target_by_identity.get(baseline_record.identity)
+        if target_record is None:
+            choices = target_by_field_path.get(baseline_record.field_path, [])
+            if choices:
+                target_record, candidates = _best_s3_record_match(
+                    baseline_record, choices, match_threshold
+                )
+                if candidates:
+                    candidate_summary[baseline_record.uri] = candidates
+            if target_record is None:
+                skipped.append(
+                    f"{baseline_record.field_path}: no target URI matched {baseline_record.uri}"
+                )
+                continue
+
+        if target_record.uri == baseline_record.uri:
+            continue
+        if target_record.key == baseline_record.key:
+            if target_record.bucket != baseline_record.bucket:
+                params[target_record.field_path] = target_record.field_value
+            continue
+
+        choices = target_by_field_path.get(baseline_record.field_path, [target_record])
+        matched_record, candidates = _best_s3_record_match(
+            baseline_record, choices, match_threshold
+        )
+        if candidates:
+            candidate_summary[baseline_record.uri] = candidates
+        if matched_record is None:
+            skipped.append(
+                f"{baseline_record.field_path}: no confident target URI matched {baseline_record.uri}"
+            )
+            continue
+        params[matched_record.field_path] = matched_record.field_value
+
+    return S3DetectionResult(
+        params=params,
+        skipped=skipped,
+        candidates=candidate_summary,
+    )
+
+
+def _best_s3_record_match(
+    baseline_record: S3UriRecord,
+    choices: list[S3UriRecord],
+    match_threshold: int,
+) -> tuple[S3UriRecord | None, list[tuple[str, int]]]:
+    if not choices:
+        return None, []
+    scored = sorted(
+        (
+            (record, int(fuzz.ratio(baseline_record.key, record.key)))
+            for record in choices
+        ),
+        key=lambda item: item[1],
+        reverse=True,
+    )
+    candidates = [(record.uri, score) for record, score in scored[:2]]
+    best_record, best_score = scored[0]
+    if best_score < match_threshold:
+        return None, candidates
+    return best_record, candidates
+
+
+def _fetch_profile_job_configs(
+    *,
+    profile_jobs: Mapping[str, str],
+    auto_login: bool,
+) -> tuple[dict[str, dict[str, Any]], dict[str, str]]:
+    configs: dict[str, dict[str, Any]] = {}
+    errors: dict[str, str] = {}
+    for profile, job_name in profile_jobs.items():
+        try:
+            config = get_glue_job_config(
+                job_name,
+                profile_name=profile,
+                auto_login=auto_login,
+            )
+        except Exception as exc:  # noqa: BLE001 - preserve interactive fallback.
+            errors[profile] = str(exc)
+            continue
+        if isinstance(config, dict) and config:
+            configs[profile] = config
+        else:
+            errors[profile] = "Glue returned an empty job config."
+    return configs, errors
+
+
+def _print_missing_checkout_job_recommendation(
+    *,
+    profile: str,
+    job_name: str,
+) -> None:
+    typer.echo(
+        f"Recommendation: AWS profile '{profile}' could not fetch the checked-out "
+        f"job '{job_name}'. If that checkout is stale, clear it and rerun init:",
+        err=True,
+    )
+    typer.echo("  gluekit checkout --clear", err=True)
+    typer.echo(
+        "Then run `gluekit init` again; with no job checked out, pressing Enter at "
+        "the job prompt will list Glue jobs from the selected profile.",
+        err=True,
+    )
+    typer.echo(
+        "You can also inspect that profile directly with:",
+        err=True,
+    )
+    typer.echo(
+        f"  aws glue get-jobs --profile {profile} --query 'Jobs[].Name' --output table",
+        err=True,
+    )
+    typer.echo(
+        "If the job exists in that profile, reselect it with the profile:",
+        err=True,
+    )
+    typer.echo(
+        f"  gluekit checkout {shlex.quote(job_name)} --profile {shlex.quote(profile)}",
+        err=True,
+    )
+
+
+def _parse_profile_job_options(profile_job: list[str]) -> dict[str, str]:
+    profile_jobs: dict[str, str] = {}
+    for raw_value in profile_job:
+        profile, separator, job_name = raw_value.partition("=")
+        if not separator or not profile.strip() or not job_name.strip():
+            raise typer.BadParameter(
+                "--profile-job must be provided as PROFILE=GLUE_JOB_NAME."
+            )
+        profile_jobs[profile.strip()] = job_name.strip()
+    return profile_jobs
+
+
+def _job_modified_sort_value(job: dict[str, Any]) -> datetime:
+    value = job.get("LastModifiedOn") or job.get("CreatedOn")
+    if isinstance(value, datetime):
+        if value.tzinfo is None:
+            return value.replace(tzinfo=timezone.utc)
+        return value
+    return datetime.min.replace(tzinfo=timezone.utc)
+
+
+def _render_job_modified(job: dict[str, Any]) -> str:
+    value = job.get("LastModifiedOn") or job.get("CreatedOn")
+    if isinstance(value, datetime):
+        return value.isoformat()
+    if value:
+        return str(value)
+    return "unknown modified time"
+
+
+def _select_job_from_profile_listing(
+    *,
+    profile: str,
+    auto_login: bool,
+) -> str | None:
+    try:
+        jobs = list_glue_jobs(profile_name=profile, auto_login=auto_login)
+    except Exception as exc:  # noqa: BLE001 - keep init interactive.
+        typer.echo(f"Could not list Glue jobs for {profile}: {exc}", err=True)
+        jobs = []
+
+    named_jobs = [
+        job for job in jobs if isinstance(job, dict) and isinstance(job.get("Name"), str)
+    ]
+    named_jobs.sort(key=_job_modified_sort_value, reverse=True)
+    if not named_jobs:
+        return typer.prompt(
+            f"Glue job name for profile '{profile}'",
+            default="",
+            show_default=False,
+        ).strip() or None
+
+    typer.echo(f"Glue jobs for profile '{profile}':")
+    for index, job in enumerate(named_jobs, start=1):
+        typer.echo(f"{index}. {job['Name']} ({_render_job_modified(job)})")
+
+    names = {job["Name"] for job in named_jobs}
+    while True:
+        selection = typer.prompt(
+            f"Select Glue job for profile '{profile}' by number or name",
+            default="",
+            show_default=False,
+        ).strip()
+        if not selection:
+            return None
+        if selection.isdigit():
+            index = int(selection)
+            if 1 <= index <= len(named_jobs):
+                return named_jobs[index - 1]["Name"]
+        if selection in names:
+            return selection
+        typer.echo("Enter a listed number, an exact job name, or press Enter to skip.")
+
+
+def _prompt_source_job_for_profile(
+    *,
+    profile: str,
+    default_job: str,
+    profile_job_overrides: Mapping[str, str],
+    auto_login: bool,
+) -> str | None:
+    override = profile_job_overrides.get(profile)
+    if override:
+        typer.echo(f"Using Glue job '{override}' for profile '{profile}'.")
+        return override
+
+    prompt_text = f"Glue job to inspect for profile '{profile}'"
+    if default_job:
+        return typer.prompt(prompt_text, default=default_job).strip() or None
+
+    job_name = typer.prompt(prompt_text, default="", show_default=False).strip()
+    if job_name:
+        return job_name
+
+    return _select_job_from_profile_listing(
+        profile=profile,
+        auto_login=auto_login,
+    )
+
+
+def _add_detected_param(
+    detected_params: dict[str, dict[str, Any]],
+    *,
+    profile: str,
+    key: str,
+    value: Any,
+) -> None:
+    detected_params.setdefault(profile, {})[key] = value
+
+
+def _prompt_manual_param_for_skip(
+    *,
+    profile: str,
+    reason: str,
+    detected_params: dict[str, dict[str, Any]],
+) -> None:
+    typer.echo(f"Skipped S3 detection for {profile}: {reason}")
+    if not typer.confirm(f"Enter a manual profile param for {profile}?", default=False):
+        return
+    key = typer.prompt("Param key")
+    value = typer.prompt("Param value")
+    if key.strip():
+        _add_detected_param(
+            detected_params,
+            profile=profile,
+            key=key.strip(),
+            value=value,
+        )
+
+
+def _print_detection_summary(
+    *,
+    local_job_name: str,
+    profile_source_jobs: Mapping[str, str],
+    detected_params: dict[str, dict[str, Any]],
+    skipped: dict[str, list[str]],
+    candidates: dict[str, dict[str, list[tuple[str, int]]]],
+) -> None:
+    typer.echo("Profile source jobs:")
+    for profile in sorted(profile_source_jobs):
+        typer.echo(f"- {profile}: {profile_source_jobs[profile]} -> {local_job_name}")
+
+    typer.echo("Detected profile params:")
+    if not detected_params:
+        typer.echo("- (none)")
+    for profile in sorted(detected_params):
+        typer.echo(f"- {profile}:")
+        for key, value in sorted(detected_params[profile].items()):
+            typer.echo(f"  {key}: {value}")
+
+    if candidates:
+        typer.echo("S3 match candidates:")
+        for profile in sorted(candidates):
+            for source_uri, matches in sorted(candidates[profile].items()):
+                rendered = ", ".join(f"{uri} ({score})" for uri, score in matches)
+                typer.echo(f"- {profile}: {source_uri} -> {rendered}")
+
+    if skipped:
+        typer.echo("Skipped S3 detections:")
+        for profile in sorted(skipped):
+            for reason in skipped[profile]:
+                typer.echo(f"- {profile}: {reason}")
+
+
+def _glue_init(
+    *,
+    aws_config: Path,
+    config_dir: Path,
+    auto_login: bool,
+    detect_roles: bool,
+    detect_buckets: bool,
+    match_threshold: int,
+    baseline_profile: Optional[str],
+    profile_job: list[str],
+) -> None:
+    if match_threshold < 0 or match_threshold > 100:
+        raise typer.BadParameter("--match-threshold must be between 0 and 100.")
+
+    profile_job_overrides = _parse_profile_job_options(profile_job)
+    profiles = _aws_profiles_from_config(aws_config)
+    if not profiles:
+        typer.echo(f"No AWS profiles found in {aws_config}.")
+        return
+
+    selected_profiles: list[str] = []
+    profile_source_jobs: dict[str, str] = {}
+    checked_out_jobs = _get_checked_out_jobs()
+    default_job = checked_out_jobs[0] if len(checked_out_jobs) == 1 else ""
+    for profile in profiles:
+        if typer.confirm(
+            f"Use AWS profile '{profile}' in this repository?", default=False
+        ):
+            source_job = _prompt_source_job_for_profile(
+                profile=profile,
+                default_job=default_job,
+                profile_job_overrides=profile_job_overrides,
+                auto_login=auto_login,
+            )
+            if not source_job:
+                typer.echo(
+                    f"Skipping profile '{profile}' because no Glue job was selected."
+                )
+                continue
+            selected_profiles.append(profile)
+            profile_source_jobs[profile] = source_job
+
+    if not selected_profiles:
+        typer.echo("No profiles selected.")
+        return
+
+    missing_overrides = sorted(set(profile_job_overrides) - set(selected_profiles))
+    if missing_overrides:
+        raise typer.BadParameter(
+            "--profile-job was provided for profiles that were not selected: "
+            + ", ".join(missing_overrides)
+        )
+
+    store = _load_glue_set_store()
+    profiles_store = store.setdefault("profiles", {})
+    for profile in selected_profiles:
+        profile_store = profiles_store.setdefault(profile, {})
+        if not isinstance(profile_store, dict):
+            profiles_store[profile] = {"global": {}, "jobs": {}}
+            continue
+        profile_store.setdefault("global", {})
+        profile_store.setdefault("jobs", {})
+    _save_glue_set_store(store)
+
+    local_job_name = default_job or profile_source_jobs[selected_profiles[0]]
+    resolved_job_name, source = _resolve_checkout_job_name(
+        local_job_name, config_dir=config_dir
+    )
+    if baseline_profile:
+        first_profile = baseline_profile
+    else:
+        first_profile = typer.prompt(
+            "Profile to checkout first / use as S3 baseline",
+            default=selected_profiles[0],
+        )
+    if first_profile not in selected_profiles:
+        raise typer.BadParameter(
+            f"Profile '{first_profile}' was not selected for this repository."
+        )
+    _save_checked_out_jobs(
+        [resolved_job_name],
+        resolved_job_name,
+        source=source,
+        profile=first_profile,
+    )
+    typer.echo(f"Checked out {resolved_job_name} with profile {first_profile}.")
+
+    role_detection_enabled = detect_roles and typer.confirm(
+        "Auto-detect profile-specific Glue IAM roles?", default=True
+    )
+    bucket_detection_enabled = detect_buckets and typer.confirm(
+        "Auto-detect profile-specific S3 bucket mappings?", default=True
+    )
+
+    detected_params: dict[str, dict[str, Any]] = {}
+    skipped_s3: dict[str, list[str]] = {}
+    s3_candidates: dict[str, dict[str, list[tuple[str, int]]]] = {}
+
+    profile_configs: dict[str, dict[str, Any]] = {}
+    profile_errors: dict[str, str] = {}
+    if role_detection_enabled or bucket_detection_enabled:
+        profile_configs, profile_errors = _fetch_profile_job_configs(
+            profile_jobs=profile_source_jobs,
+            auto_login=auto_login,
+        )
+        for profile, error in sorted(profile_errors.items()):
+            typer.echo(
+                f"Could not fetch Glue job config for {profile} "
+                f"({profile_source_jobs[profile]}): {error}",
+                err=True,
+            )
+            if default_job and profile_source_jobs[profile] == default_job:
+                _print_missing_checkout_job_recommendation(
+                    profile=profile,
+                    job_name=default_job,
+                )
+
+    if role_detection_enabled:
+        for profile in selected_profiles:
+            role = profile_configs.get(profile, {}).get("Role")
+            if isinstance(role, str) and role.strip():
+                _add_detected_param(
+                    detected_params,
+                    profile=profile,
+                    key="Role",
+                    value=role.strip(),
+                )
+                continue
+            role = typer.prompt(f"Role for {profile}", default="")
+            if role.strip():
+                _add_detected_param(
+                    detected_params,
+                    profile=profile,
+                    key="Role",
+                    value=role.strip(),
+                )
+
+    if bucket_detection_enabled:
+        baseline_config = profile_configs.get(first_profile)
+        if not baseline_config:
+            typer.echo(
+                f"Cannot detect S3 bucket mappings without baseline config for {first_profile}.",
+                err=True,
+            )
+        else:
+            for profile in selected_profiles:
+                if profile == first_profile:
+                    continue
+                target_config = profile_configs.get(profile)
+                if not target_config:
+                    continue
+                result = detect_profile_s3_params(
+                    baseline_config=baseline_config,
+                    target_config=target_config,
+                    match_threshold=match_threshold,
+                )
+                for key, value in result.params.items():
+                    _add_detected_param(
+                        detected_params,
+                        profile=profile,
+                        key=key,
+                        value=value,
+                    )
+                if result.skipped:
+                    skipped_s3[profile] = list(result.skipped)
+                if result.candidates:
+                    s3_candidates[profile] = dict(result.candidates)
+
+            for profile, reasons in skipped_s3.items():
+                for reason in reasons:
+                    _prompt_manual_param_for_skip(
+                        profile=profile,
+                        reason=reason,
+                        detected_params=detected_params,
+                    )
+
+    if role_detection_enabled or bucket_detection_enabled:
+        _print_detection_summary(
+            local_job_name=resolved_job_name,
+            profile_source_jobs=profile_source_jobs,
+            detected_params=detected_params,
+            skipped=skipped_s3,
+            candidates=s3_candidates,
+        )
+        for profile, params in detected_params.items():
+            for key, value in params.items():
+                _save_profile_param(
+                    profile=profile,
+                    job_name=resolved_job_name,
+                    key=key,
+                    value=value,
+                )
+
+    if typer.confirm(
+        "Pull the baseline Glue job now using the checkout profile?", default=False
+    ):
+        source_job_name = profile_source_jobs[first_profile]
+        if source_job_name != resolved_job_name:
+            raise typer.BadParameter(
+                "Pulling during init requires the baseline source job to match the "
+                f"local checked-out job ({resolved_job_name}); selected "
+                f"{source_job_name} for {first_profile}."
+            )
+        config_dir.mkdir(parents=True, exist_ok=True)
+        jobs = list_glue_jobs(profile_name=first_profile, auto_login=auto_login)
+        matches = [job for job in jobs if job.get("Name") == source_job_name]
+        if not matches:
+            raise typer.BadParameter(
+                f'No Glue job named "{source_job_name}" found for profile {first_profile}.'
+            )
+        config_path = config_dir / f"{slugify(resolved_job_name)}.json"
+        download_glue_job_files(
+            name=source_job_name,
+            local_path=f"glue/scripts/{slugify(resolved_job_name)}.py",
+            config_path=config_path,
+            include_components={"config", "script", "notebook"},
+            existing_sc={},
+            profile_name=first_profile,
+            auto_login=auto_login,
+        )
+
+    store = _load_glue_set_store()
+    automation = store.setdefault("automation", {})
+    if isinstance(automation, dict):
+        automation["profiles"] = selected_profiles
+        automation["source_jobs"] = profile_source_jobs
+        automation["default_job"] = resolved_job_name
+        automation["build"] = {
+            "package_whl": typer.confirm(
+                "Default build flow should refresh dist/*.whl in Glue config?",
+                default=True,
+            ),
+            "push": typer.confirm(
+                "Default build flow should push after build?",
+                default=False,
+            ),
+        }
+        automation["local_dev_file_type"] = typer.prompt(
+            "Local development file type",
+            default="notebook",
+        )
+        _save_glue_set_store(store)
+    typer.echo(f"Saved setup in {GLUE_SET_FILE}.")
+
+
+@app.command(
+    "init",
+    epilog=_examples_epilog(
+        "gluekit init",
+    ),
+)
+def glue_init(
+    aws_config: Optional[Path] = typer.Option(
+        None,
+        "--aws-config",
+        help="Local AWS CLI config file to scan for credential profile names; defaults to AWS_CONFIG_FILE or ~/.aws/config.",
+    ),
+    config_dir: Path = typer.Option(
+        Path("glue/configs"),
+        "--config-dir",
+        help="Directory containing Glue job config files.",
+    ),
+    auto_login: bool = typer.Option(
+        True,
+        "--auto-login/--no-auto-login",
+        help="For selected real AWS profiles, automatically run 'aws sso login' when credentials are missing or expired.",
+    ),
+    detect_roles: bool = typer.Option(
+        True,
+        "--detect-roles/--no-detect-roles",
+        help="Fetch the selected real AWS Glue job in each profile and save its Role as local gluekit params.",
+    ),
+    detect_buckets: bool = typer.Option(
+        True,
+        "--detect-buckets/--no-detect-buckets",
+        help="Compare S3 URIs in real AWS Glue job configs across profiles and save local gluekit profile mappings.",
+    ),
+    match_threshold: int = typer.Option(
+        85,
+        "--match-threshold",
+        help="Minimum rapidfuzz score for non-exact S3 key matches.",
+    ),
+    baseline_profile: Optional[str] = typer.Option(
+        None,
+        "--baseline-profile",
+        help="Selected AWS CLI profile to store as the first gluekit checkout scope and S3 comparison baseline.",
+    ),
+    profile_job: Optional[list[str]] = typer.Option(
+        None,
+        "--profile-job",
+        help="Real AWS Glue job to inspect for an AWS CLI profile, as PROFILE=GLUE_JOB_NAME. May be repeated.",
+    ),
+) -> None:
+    """Initialize local repo-level Gluekit settings from AWS CLI profiles."""
+    resolved_aws_config = aws_config or Path(
+        os.environ.get("AWS_CONFIG_FILE", Path.home() / ".aws" / "config")
+    )
+    _glue_init(
+        aws_config=resolved_aws_config,
+        config_dir=config_dir,
+        auto_login=auto_login,
+        detect_roles=detect_roles,
+        detect_buckets=detect_buckets,
+        match_threshold=match_threshold,
+        baseline_profile=baseline_profile,
+        profile_job=profile_job or [],
+    )