Skip to content

BumpyClock/agent-templates / skills/ios-macos-development

ios-macos-development

Unverified

Build, debug, or release iOS and macOS apps with Swift and Apple platform tools.

FileKindSize
SKILL.mdskill md2.1 KB
agents/openai.yamlconfig278 B
app-store-connect-cli/asc-app-create-ui/guide.mdmarkdown6.3 KB
app-store-connect-cli/asc-build-lifecycle/guide.mdmarkdown1.8 KB
app-store-connect-cli/asc-cli-usage/guide.mdmarkdown1.3 KB
app-store-connect-cli/asc-id-resolver/guide.mdmarkdown1.3 KB
app-store-connect-cli/asc-metadata-sync/guide.mdmarkdown4.5 KB
app-store-connect-cli/asc-notarization/guide.mdmarkdown7.2 KB
app-store-connect-cli/asc-ppp-pricing/guide.mdmarkdown4.4 KB
app-store-connect-cli/asc-release-flow/guide.mdmarkdown4.7 KB
app-store-connect-cli/asc-shots-pipeline/guide.mdmarkdown10.7 KB
app-store-connect-cli/asc-signing-setup/guide.mdmarkdown2.6 KB
app-store-connect-cli/asc-submission-health/guide.mdmarkdown6.9 KB
app-store-connect-cli/asc-subscription-localization/guide.mdmarkdown10.2 KB
app-store-connect-cli/asc-testflight-orchestration/guide.mdmarkdown1.7 KB
app-store-connect-cli/asc-workflow/guide.mdmarkdown5.3 KB
app-store-connect-cli/asc-xcode-build/guide.mdmarkdown3.7 KB
app-store-connect-cli/guide.mdmarkdown3.6 KB
instruments-profiling/guide.mdmarkdown3.7 KB
ios-app-intents/guide.mdmarkdown4.8 KB
ios-app-intents/references/code-templates.mdmarkdown7.4 KB
ios-app-intents/references/example-patterns.mdmarkdown3.6 KB
ios-app-intents/references/first-pass-checklist.mdmarkdown1.4 KB
ios-app-intents/references/system-surfaces.mdmarkdown1.0 KB
ios-debugger-agent/guide.mdmarkdown2.7 KB
ios-simulator/guide.mdmarkdown21.0 KB
ios-simulator/references/accessibility_checklist.mdmarkdown1.5 KB
ios-simulator/references/idb_quick.mdmarkdown1.1 KB
ios-simulator/references/simctl_quick.mdmarkdown1.3 KB
ios-simulator/references/test_patterns.mdmarkdown1.6 KB
ios-simulator/references/troubleshooting.mdmarkdown1.3 KB
ios-simulator/scripts/accessibility_audit.pyexecutablescript10.3 KB
ios-simulator/scripts/app_launcher.pyexecutablescript9.7 KB
ios-simulator/scripts/app_state_capture.pyexecutablescript13.2 KB
ios-simulator/scripts/appearance.pyscript11.3 KB
ios-simulator/scripts/build_and_test.pyexecutablescript11.3 KB
ios-simulator/scripts/clipboard.pyscript2.6 KB
ios-simulator/scripts/common/__init__.pyscript1.5 KB
ios-simulator/scripts/common/cache_utils.pyscript9.3 KB
ios-simulator/scripts/common/device_utils.pyscript13.5 KB
ios-simulator/scripts/common/env_config.pyscript1.1 KB
ios-simulator/scripts/common/hang_pipeline.pyscript29.6 KB
ios-simulator/scripts/common/hang_sessions.pyscript17.9 KB
ios-simulator/scripts/common/idb_utils.pyscript5.3 KB
ios-simulator/scripts/common/screenshot_utils.pyscript10.0 KB
ios-simulator/scripts/container.pyscript22.7 KB
ios-simulator/scripts/gesture.pyexecutablescript12.3 KB
ios-simulator/scripts/hang_watcher.pyscript56.5 KB
ios-simulator/scripts/keyboard.pyexecutablescript11.5 KB
ios-simulator/scripts/localization_audit.pyscript16.2 KB
ios-simulator/scripts/location.pyscript15.4 KB
ios-simulator/scripts/log_monitor.pyexecutablescript14.8 KB
ios-simulator/scripts/model_inspector.pyscript21.7 KB
ios-simulator/scripts/navigator.pyexecutablescript14.2 KB
ios-simulator/scripts/privacy_manager.pyscript8.7 KB
ios-simulator/scripts/push_notification.pyscript6.5 KB
ios-simulator/scripts/screen_mapper.pyexecutablescript10.7 KB
ios-simulator/scripts/sim_health_check.shscript8.1 KB
ios-simulator/scripts/sim_list.pyscript8.9 KB
ios-simulator/scripts/simctl_boot.pyexecutablescript9.1 KB
ios-simulator/scripts/simctl_create.pyexecutablescript8.9 KB
ios-simulator/scripts/simctl_delete.pyexecutablescript10.3 KB
ios-simulator/scripts/simctl_erase.pyexecutablescript10.2 KB
ios-simulator/scripts/simctl_shutdown.pyexecutablescript8.4 KB
ios-simulator/scripts/simulator_selector.pyexecutablescript10.3 KB
ios-simulator/scripts/status_bar.pyscript6.6 KB
ios-simulator/scripts/test_recorder.pyexecutablescript10.6 KB
ios-simulator/scripts/visual_diff.pyexecutablescript7.6 KB
ios-simulator/scripts/xcode/__init__.pyscript378 B
ios-simulator/scripts/xcode/builder.pyscript13.2 KB
ios-simulator/scripts/xcode/cache.pyscript5.5 KB
ios-simulator/scripts/xcode/config.pyscript5.4 KB
ios-simulator/scripts/xcode/reporter.pyscript10.7 KB
ios-simulator/scripts/xcode/xcresult.pyscript16.5 KB
native-app-performance/attribution.txtmarkdown349 B
native-app-performance/guide.mdmarkdown2.1 KB
native-app-performance/scripts/extract_time_samples.pyscript1.1 KB
native-app-performance/scripts/record_time_profiler.shscript1.3 KB
native-app-performance/scripts/top_hotspots.pyscript4.0 KB
swift-concurrency-expert/attribution.txtmarkdown353 B
swift-concurrency-expert/guide.mdmarkdown1.9 KB
swift-concurrency-expert/references/swift-6-2-concurrency.mdmarkdown4.3 KB
swift-concurrency-expert/references/swiftui-concurrency-tour-wwdc.mdmarkdown1.6 KB
swift-ui/guide.mdmarkdown1.0 KB
swift-ui/references/index.mdmarkdown4.2 KB
swift-ui/references/liquid-glass/appkit.mdmarkdown3.3 KB
swift-ui/references/liquid-glass/overview.mdmarkdown1.6 KB
swift-ui/references/liquid-glass/patterns.mdmarkdown3.9 KB
swift-ui/references/liquid-glass/swiftui.mdmarkdown4.0 KB
swift-ui/references/logging-private-fix.mdmarkdown8.0 KB
swift-ui/references/modern-swift.mdmarkdown2.9 KB
swift-ui/references/swift-concurrency.mdmarkdown39.6 KB
swift-ui/references/swift-testing-playbook.mdmarkdown35.3 KB
swift-ui/references/swiftui.mdmarkdown1.8 MB
swift-ui/references/toolbar/swiftui-features.mdmarkdown4.7 KB
swiftui-liquid-glass/attribution.txtmarkdown345 B
swiftui-liquid-glass/guide.mdmarkdown4.1 KB
swiftui-liquid-glass/references/liquid-glass.mdmarkdown8.0 KB
swiftui-performance-audit/attribution.txtmarkdown355 B
swiftui-performance-audit/guide.mdmarkdown1.7 KB
swiftui-performance-audit/references/code-smells.mdmarkdown4.8 KB
swiftui-performance-audit/references/demystify-swiftui-performance-wwdc23.mdmarkdown1.8 KB
swiftui-performance-audit/references/optimizing-swiftui-performance-instruments.mdmarkdown1.8 KB
swiftui-performance-audit/references/profiling-intake.mdmarkdown2.4 KB
swiftui-performance-audit/references/report-template.mdmarkdown1.2 KB
swiftui-performance-audit/references/understanding-hangs-in-your-app.mdmarkdown1.2 KB
swiftui-performance-audit/references/understanding-improving-swiftui-performance.mdmarkdown2.2 KB
swiftui-ui-patterns/guide.mdmarkdown2.0 KB
swiftui-ui-patterns/references/app-wiring.mdmarkdown6.5 KB
swiftui-ui-patterns/references/async-state.mdmarkdown3.5 KB
swiftui-ui-patterns/references/components-index.mdmarkdown4.2 KB
swiftui-ui-patterns/references/controls.mdmarkdown1.6 KB
swiftui-ui-patterns/references/deeplinks.mdmarkdown1.7 KB
swiftui-ui-patterns/references/focus.mdmarkdown2.3 KB
swiftui-ui-patterns/references/form.mdmarkdown3.0 KB
swiftui-ui-patterns/references/grids.mdmarkdown1.8 KB
swiftui-ui-patterns/references/haptics.mdmarkdown2.0 KB
swiftui-ui-patterns/references/input-toolbar.mdmarkdown1.4 KB
swiftui-ui-patterns/references/lightweight-clients.mdmarkdown2.5 KB
swiftui-ui-patterns/references/list.mdmarkdown2.7 KB
swiftui-ui-patterns/references/loading-placeholders.mdmarkdown1.2 KB
swiftui-ui-patterns/references/macos-settings.mdmarkdown2.0 KB
swiftui-ui-patterns/references/matched-transitions.mdmarkdown1.6 KB
swiftui-ui-patterns/references/media.mdmarkdown2.0 KB
swiftui-ui-patterns/references/menu-bar.mdmarkdown2.2 KB
swiftui-ui-patterns/references/navigationstack.mdmarkdown4.2 KB
swiftui-ui-patterns/references/overlay.mdmarkdown1.2 KB
swiftui-ui-patterns/references/performance.mdmarkdown1.9 KB
swiftui-ui-patterns/references/previews.mdmarkdown1.6 KB
swiftui-ui-patterns/references/scroll-reveal.mdmarkdown5.2 KB
swiftui-ui-patterns/references/scrollview.mdmarkdown2.3 KB
swiftui-ui-patterns/references/searchable.mdmarkdown1.7 KB
swiftui-ui-patterns/references/sheets.mdmarkdown4.3 KB
swiftui-ui-patterns/references/split-views.mdmarkdown2.0 KB
swiftui-ui-patterns/references/tabview.mdmarkdown3.4 KB
swiftui-ui-patterns/references/theming.mdmarkdown1.7 KB
swiftui-ui-patterns/references/title-menus.mdmarkdown2.1 KB
swiftui-ui-patterns/references/top-bar.mdmarkdown1.3 KB
swiftui-view-refactor/guide.mdmarkdown1.6 KB
swiftui-view-refactor/references/mv-patterns.mdmarkdown2.3 KB

ios-simulator/scripts/localization_audit.py

View on GitHub
#!/usr/bin/env python3
"""
iOS Localization Catalog Audit

Parses .xcstrings (JSON) or .strings/.stringsdict (plist) catalogs and reports:
  - Per-locale missing/untranslated keys
  - Keys in source but absent from catalog (missing)
  - Keys in catalog but absent from source (unused)
  - Format-specifier placeholder mismatches across locales

Pure file analysis — no simulator interaction required.

Usage:
    python scripts/localization_audit.py --catalog Localizable.xcstrings
    python scripts/localization_audit.py --catalog Localizable.xcstrings --source ./MyApp
    python scripts/localization_audit.py --catalog Localizable.xcstrings --strict
"""

import argparse
import json
import plistlib
import re
import sys
from dataclasses import asdict, dataclass, field
from pathlib import Path
from typing import Any

# === TYPES ===


@dataclass
class LocaleGap:
    """A key that is missing or needs review in a specific locale."""

    key: str
    locale: str
    reason: str  # "missing", "needs_review", "new", "stale"


@dataclass
class PlaceholderMismatch:
    """A key where placeholder counts differ across locales."""

    key: str
    source_locale: str
    source_placeholders: list[str]
    offending_locale: str
    offending_placeholders: list[str]


@dataclass
class AuditReport:
    """Structured result of a full catalog audit."""

    catalog_path: str
    source_language: str
    total_keys: int
    locales: list[str]
    gaps: list[LocaleGap] = field(default_factory=list)
    missing_from_catalog: list[str] = field(default_factory=list)  # in source, not catalog
    unused_in_source: list[str] = field(default_factory=list)  # in catalog, not source
    placeholder_mismatches: list[PlaceholderMismatch] = field(default_factory=list)

    def has_findings(self) -> bool:
        return bool(
            self.gaps
            or self.missing_from_catalog
            or self.unused_in_source
            or self.placeholder_mismatches
        )

    def to_dict(self) -> dict[str, Any]:
        return asdict(self)


# === PLACEHOLDER EXTRACTION ===

# Matches %d, %@, %s, %lld, %ld, %f, %g, %i, %u and positional %1$@, %2$d etc.
# Length-modifier group (hh|h|ll|l|z|t|q) handles %lld, %lu, %ld, %hhu etc.
_PLACEHOLDER_RE = re.compile(
    r"%(?:\d+\$)?(?:[-+0 #]*)?(?:\d+)?(?:\.\d+)?(?:hh|h|ll|l|z|t|q)?[diouxXeEfgGcsSpaAqQzZtb@]"
)

# Swift source patterns for localized strings
_SWIFT_LOCALIZED_RE = re.compile(
    r'String\s*\(\s*localized\s*:\s*"([^"\\]*(?:\\.[^"\\]*)*)"|'
    r'NSLocalizedString\s*\(\s*"([^"\\]*(?:\\.[^"\\]*)*)"'
)


def _extract_placeholders(value: str) -> list[str]:
    """Extract all format specifiers from a string value."""
    return _PLACEHOLDER_RE.findall(value)


# === XCSTRINGS PARSER ===


def _parse_xcstrings(catalog_path: Path) -> tuple[str, dict[str, dict[str, Any]]]:
    """
    Parse an .xcstrings JSON catalog.

    Returns:
        (source_language, strings_dict)
        strings_dict maps key -> {locale -> {"state": ..., "value": ...}}
    """
    try:
        raw = json.loads(catalog_path.read_text(encoding="utf-8"))
    except json.JSONDecodeError as exc:
        raise ValueError(f"Invalid JSON in {catalog_path}: {exc}") from exc

    source_language: str = raw.get("sourceLanguage", "en")
    raw_strings: dict = raw.get("strings", {})

    strings: dict[str, dict[str, Any]] = {}
    for key, entry in raw_strings.items():
        localizations: dict = entry.get("localizations", {})
        strings[key] = {}
        for locale, loc_data in localizations.items():
            if "stringUnit" in loc_data:
                unit = loc_data["stringUnit"]
                strings[key][locale] = {
                    "state": unit.get("state", ""),
                    "value": unit.get("value", ""),
                }
            elif "variations" in loc_data:
                # Plural variations — grab first available unit for placeholder check
                variations = loc_data["variations"]
                plural = variations.get("plural", {})
                first_variant = next(iter(plural.values()), {})
                unit = first_variant.get("stringUnit", {})
                strings[key][locale] = {
                    "state": unit.get("state", ""),
                    "value": unit.get("value", ""),
                }

    return source_language, strings


# === LEGACY .strings / .stringsdict PARSER ===


def _parse_strings_file(catalog_path: Path) -> tuple[str, dict[str, dict[str, Any]]]:
    """
    Parse a legacy .strings or .stringsdict file via plistlib.

    .strings files are treated as a single-locale catalog whose locale is
    inferred from the path (e.g. en.lproj/Localizable.strings → "en").
    Returns a minimal structure compatible with the audit logic.
    """
    # Attempt to infer locale from parent directory (e.g. "en.lproj")
    parent = catalog_path.parent.name
    locale = parent.removesuffix(".lproj") if parent.endswith(".lproj") else "unknown"
    source_language = locale

    suffix = catalog_path.suffix.lower()

    if suffix == ".stringsdict":
        try:
            data = plistlib.loads(catalog_path.read_bytes())
        except Exception as exc:
            raise ValueError(f"Failed to parse .stringsdict {catalog_path}: {exc}") from exc
        # Each key maps to a plural rule dict — extract NSStringLocalizedFormatKey as value
        strings: dict[str, dict[str, Any]] = {}
        for key, plural_dict in data.items():
            value = plural_dict.get("NSStringLocalizedFormatKey", "")
            strings[key] = {locale: {"state": "translated", "value": value}}
        return source_language, strings

    # .strings — may be binary or XML plist, or legacy =; format
    plist_error: Exception | None = None
    try:
        data = plistlib.loads(catalog_path.read_bytes())
        strings = {k: {locale: {"state": "translated", "value": v}} for k, v in data.items()}
        return source_language, strings
    except Exception as exc:
        plist_error = exc

    # Fallback: text-format .strings  ("key" = "value";)
    _kv_re = re.compile(r'"((?:[^"\\]|\\.)*)"\s*=\s*"((?:[^"\\]|\\.)*)"', re.MULTILINE)
    text_error: Exception | None = None
    try:
        try:
            text = catalog_path.read_text(encoding="utf-8")
        except UnicodeDecodeError as exc:
            text_error = exc
            text = catalog_path.read_text(encoding="latin-1")
        strings = {}
        for match in _kv_re.finditer(text):
            k, v = match.group(1), match.group(2)
            strings[k] = {locale: {"state": "translated", "value": v}}
        return source_language, strings
    except Exception as exc:
        if text_error is None:
            text_error = exc

    raise ValueError(
        f"Failed to parse .strings file {catalog_path}: "
        f"plist error: {plist_error}; text-decode error: {text_error}"
    )


# === SWIFT SOURCE SCANNER ===


def _scan_swift_sources(source_dir: Path) -> set[str]:
    """
    Scan *.swift files under source_dir for localized string keys.

    Matches:
        String(localized: "key")
        NSLocalizedString("key", ...)

    Note: regex-based for v1 — swift-syntax AST parsing would be more robust
    for multiline literals and string interpolation edge-cases.
    """
    keys: set[str] = set()
    for swift_file in source_dir.rglob("*.swift"):
        try:
            content = swift_file.read_text(encoding="utf-8")
        except OSError:
            continue
        for match in _SWIFT_LOCALIZED_RE.finditer(content):
            key = match.group(1) or match.group(2)
            if key:
                keys.add(key)
    return keys


# === CORE AUDITOR ===


class LocalizationAuditor:
    """Audits an .xcstrings or legacy .strings catalog for localization gaps."""

    def __init__(self, catalog_path: Path, source_dir: Path | None = None):
        self.catalog_path = catalog_path
        self.source_dir = source_dir

    def _load_catalog(self) -> tuple[str, dict[str, dict[str, Any]]]:
        suffix = self.catalog_path.suffix.lower()
        if suffix == ".xcstrings":
            return _parse_xcstrings(self.catalog_path)
        if suffix in {".strings", ".stringsdict"}:
            return _parse_strings_file(self.catalog_path)
        raise ValueError(
            f"Unsupported catalog format '{suffix}'. "
            "Expected .xcstrings, .strings, or .stringsdict."
        )

    def _collect_gaps(
        self,
        strings: dict[str, dict[str, Any]],
        all_locales: set[str],
        source_language: str,
    ) -> list[LocaleGap]:
        """Find keys with missing or needs-review translations per locale."""
        gaps: list[LocaleGap] = []
        non_source_locales = all_locales - {source_language}

        for key, locale_map in strings.items():
            for locale in non_source_locales:
                if locale not in locale_map:
                    gaps.append(LocaleGap(key=key, locale=locale, reason="missing"))
                else:
                    state = locale_map[locale].get("state", "")
                    if state in {"needs_review", "new", "stale"}:
                        gaps.append(LocaleGap(key=key, locale=locale, reason=state))

        return sorted(gaps, key=lambda g: (g.locale, g.key))

    def _check_placeholder_mismatches(
        self,
        strings: dict[str, dict[str, Any]],
        source_language: str,
    ) -> list[PlaceholderMismatch]:
        """Verify placeholder counts match source language for every locale."""
        mismatches: list[PlaceholderMismatch] = []

        for key, locale_map in strings.items():
            source_entry = locale_map.get(source_language)
            if not source_entry:
                continue
            source_value = source_entry.get("value", "")
            source_placeholders = _extract_placeholders(source_value)

            for locale, entry in locale_map.items():
                if locale == source_language:
                    continue
                value = entry.get("value", "")
                if not value:
                    continue  # gaps already reported separately
                locale_placeholders = _extract_placeholders(value)
                # Note: only count is compared; positional-type swaps not detected
                if len(locale_placeholders) != len(source_placeholders):
                    mismatches.append(
                        PlaceholderMismatch(
                            key=key,
                            source_locale=source_language,
                            source_placeholders=source_placeholders,
                            offending_locale=locale,
                            offending_placeholders=locale_placeholders,
                        )
                    )

        return sorted(mismatches, key=lambda m: (m.offending_locale, m.key))

    def audit(self) -> AuditReport:
        """Run the full audit and return a structured report."""
        source_language, strings = self._load_catalog()

        all_locales: set[str] = set()
        for locale_map in strings.values():
            all_locales.update(locale_map.keys())

        report = AuditReport(
            catalog_path=str(self.catalog_path),
            source_language=source_language,
            total_keys=len(strings),
            locales=sorted(all_locales),
        )

        report.gaps = self._collect_gaps(strings, all_locales, source_language)
        report.placeholder_mismatches = self._check_placeholder_mismatches(strings, source_language)

        if self.source_dir:
            source_keys = _scan_swift_sources(self.source_dir)
            catalog_keys = set(strings.keys())
            report.missing_from_catalog = sorted(source_keys - catalog_keys)
            report.unused_in_source = sorted(catalog_keys - source_keys)

        return report


# === OUTPUT FORMATTING ===


def _format_default(report: AuditReport) -> str:
    """Compact summary — 3-5 lines."""
    gap_by_locale: dict[str, int] = {}
    for gap in report.gaps:
        gap_by_locale[gap.locale] = gap_by_locale.get(gap.locale, 0) + 1

    gap_summary = ", ".join(
        f"{count} in {locale}" for locale, count in sorted(gap_by_locale.items())
    )
    if not gap_summary:
        gap_summary = "none"

    lines = [
        f"Catalog: {report.total_keys} keys, {len(report.locales)} locales, "
        f"{len(report.gaps)} gaps.",
        f"Missing/needs-review: {gap_summary}.",
    ]

    if report.missing_from_catalog:
        lines.append(f"Missing from catalog: {len(report.missing_from_catalog)} keys.")
    if report.unused_in_source:
        lines.append(f"Unused in source: {len(report.unused_in_source)} keys.")
    if report.placeholder_mismatches:
        lines.append(f"Placeholder mismatches: {len(report.placeholder_mismatches)}.")

    if not report.has_findings():
        lines.append("No issues found.")

    return "\n".join(lines)


def _format_verbose(report: AuditReport) -> str:
    """Detailed listing of every finding."""
    sections: list[str] = [_format_default(report), ""]

    if report.gaps:
        sections.append("=== Translation Gaps ===")
        current_locale = None
        for gap in report.gaps:
            if gap.locale != current_locale:
                sections.append(f"\n[{gap.locale}]")
                current_locale = gap.locale
            sections.append(f"  {gap.reason:15s}  {gap.key}")

    if report.missing_from_catalog:
        sections.append("\n=== Keys in Source, Missing from Catalog ===")
        for key in report.missing_from_catalog:
            sections.append(f"  {key}")

    if report.unused_in_source:
        sections.append("\n=== Keys in Catalog, Unused in Source ===")
        for key in report.unused_in_source:
            sections.append(f"  {key}")

    if report.placeholder_mismatches:
        sections.append("\n=== Placeholder Mismatches ===")
        for m in report.placeholder_mismatches:
            sections.append(
                f"  [{m.offending_locale}] {m.key}\n"
                f"    {m.source_locale}: {m.source_placeholders}\n"
                f"    {m.offending_locale}: {m.offending_placeholders}"
            )

    return "\n".join(sections)


# === CLI ===


def _build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(
        description="Audit .xcstrings / .strings catalogs for localization gaps.",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog="""
Examples:
  python scripts/localization_audit.py --catalog Localizable.xcstrings
  python scripts/localization_audit.py --catalog App.xcstrings --source ./MyApp
  python scripts/localization_audit.py --catalog App.xcstrings --strict --json
        """,
    )
    parser.add_argument(
        "--catalog",
        required=True,
        type=Path,
        metavar="PATH",
        help="Path to .xcstrings, .strings, or .stringsdict catalog file.",
    )
    parser.add_argument(
        "--source",
        type=Path,
        metavar="DIR",
        help="Swift source root for unused/missing key cross-reference.",
    )
    parser.add_argument(
        "--strict",
        action="store_true",
        help="Exit with non-zero status if any findings are present.",
    )
    parser.add_argument(
        "--json",
        action="store_true",
        dest="json_output",
        help="Output structured JSON report.",
    )
    parser.add_argument(
        "--verbose",
        action="store_true",
        help="List every gap, unused key, and placeholder mismatch.",
    )
    return parser


def main() -> None:
    parser = _build_parser()
    args = parser.parse_args()

    catalog_path: Path = args.catalog
    if not catalog_path.exists():
        print(f"Error: catalog not found: {catalog_path}", file=sys.stderr)
        sys.exit(1)

    source_dir: Path | None = args.source
    if source_dir is not None and not source_dir.is_dir():
        print(f"Error: source directory not found: {source_dir}", file=sys.stderr)
        sys.exit(1)

    try:
        auditor = LocalizationAuditor(catalog_path=catalog_path, source_dir=source_dir)
        report = auditor.audit()
    except ValueError as exc:
        print(f"Error: {exc}", file=sys.stderr)
        sys.exit(1)

    if args.json_output:
        print(json.dumps(report.to_dict(), indent=2))
    elif args.verbose:
        print(_format_verbose(report))
    else:
        print(_format_default(report))

    if args.strict and report.has_findings():
        sys.exit(2)


if __name__ == "__main__":
    main()
finishing-a-development-branchobra/superpowersUse when implementation is complete, all tests pass, and you need to decide how to integrate the workStars: 318kUpdated Claude CodeCodexUnverifiedInstall
systematic-debuggingobra/superpowersUse when encountering any bug, test failure, or unexpected behavior, before proposing fixesStars: 318kUpdated Claude CodeCodexUnverifiedInstall
test-driven-developmentobra/superpowersUse when implementing any feature or bugfix, before writing implementation codeStars: 318kUpdated Claude CodeCodexUnverifiedInstall
skill-creatoranthropics/skillsCreate new skills, modify and improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, edit, or optimize an existing skill, run evals to test a skill, benchmark skill performance with variance analysis, or optimize a skill's description for better triggering accuracy.Stars: 196kUpdated Claude CodeCodexVerifiedInstall