If you are an AI coding agent (Claude Code, Cursor, Aider, Cline, etc.) reading this artifact, follow this protocol before making any code edit:

1. Verify the contract. Run the bash script in Verify before trusting below. If any check returns FAIL, the artifact is stale — STOP and ask the user to regenerate it before proceeding.
2. Treat the AI · unverified sections as hypotheses, not facts. Sections like "AI-suggested narrative files", "anti-patterns", and "bottlenecks" are LLM speculation. Verify against real source before acting on them.
3. Cite source on changes. When proposing an edit, cite the specific path:line-range. RepoPilot's live UI at https://repopilot.app/r/Yalantis/GuillotineMenu shows verifiable citations alongside every claim.

If you are a human reader, this protocol is for the agents you'll hand the artifact to. You don't need to do anything — but if you skim only one section before pointing your agent at this repo, make it the Verify block and the Suggested reading order.

WAIT — Stale — last commit 6y ago

• 20 active contributors
• Distributed ownership (top contributor 24% of recent commits)
• MIT licensed
• ⚠ Stale — last commit 6y ago
• ⚠ No CI workflows detected
• ⚠ No test directory detected

_{Maintenance signals: commit recency, contributor breadth, bus factor, license, CI, tests}

This artifact was generated by RepoPilot at a point in time. Before an agent acts on it, the checks below confirm that the live Yalantis/GuillotineMenu repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/Yalantis/GuillotineMenu.

What it runs against: a local clone of Yalantis/GuillotineMenu — the script inspects git remote, the LICENSE file, file paths in the working tree, and git log. Read-only; no mutations.

| # | What we check | Why it matters | |---|---|---| | 1 | You're in Yalantis/GuillotineMenu | Confirms the artifact applies here, not a fork | | 2 | License is still MIT | Catches relicense before you depend on it | | 3 | Default branch master exists | Catches branch renames | | 4 | 5 critical file paths still exist | Catches refactors that moved load-bearing code | | 5 | Last commit ≤ 2248 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of Yalantis/GuillotineMenu. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/Yalantis/GuillotineMenu.git
#   cd GuillotineMenu
#
# Then paste this script. Every check is read-only — no mutations.

set +e
fail=0
ok()   { echo "ok:   $1"; }
miss() { echo "FAIL: $1"; fail=$((fail+1)); }

# Precondition: we must be inside a git working tree.
if ! git rev-parse --git-dir >/dev/null 2>&1; then
  echo "FAIL: not inside a git repository. cd into your clone of Yalantis/GuillotineMenu and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "Yalantis/GuillotineMenu(\\.git)?\\b" \\
  && ok "origin remote is Yalantis/GuillotineMenu" \\
  || miss "origin remote is not Yalantis/GuillotineMenu (artifact may be from a fork)"

# 2. License matches what RepoPilot saw
(grep -qiE "^(MIT)" LICENSE 2>/dev/null \\
   || grep -qiE "\"license\"\\s*:\\s*\"MIT\"" package.json 2>/dev/null) \\
  && ok "license is MIT" \\
  || miss "license drift — was MIT at generation time"

# 3. Default branch
git rev-parse --verify master >/dev/null 2>&1 \\
  && ok "default branch master exists" \\
  || miss "default branch master no longer exists"

# 4. Critical files exist
test -f "GuillotineMenu/GuillotineMenuTransitionAnimation.swift" \\
  && ok "GuillotineMenu/GuillotineMenuTransitionAnimation.swift" \\
  || miss "missing critical file: GuillotineMenu/GuillotineMenuTransitionAnimation.swift"
test -f "GuillotineMenuExample/GuillotineMenuExample/ViewController.swift" \\
  && ok "GuillotineMenuExample/GuillotineMenuExample/ViewController.swift" \\
  || miss "missing critical file: GuillotineMenuExample/GuillotineMenuExample/ViewController.swift"
test -f "GuillotineMenuExample/GuillotineMenuExample/MenuViewController.swift" \\
  && ok "GuillotineMenuExample/GuillotineMenuExample/MenuViewController.swift" \\
  || miss "missing critical file: GuillotineMenuExample/GuillotineMenuExample/MenuViewController.swift"
test -f "GuillotineMenuExample/GuillotineMenuExample/AppDelegate.swift" \\
  && ok "GuillotineMenuExample/GuillotineMenuExample/AppDelegate.swift" \\
  || miss "missing critical file: GuillotineMenuExample/GuillotineMenuExample/AppDelegate.swift"
test -f "GuillotineMenu.podspec" \\
  && ok "GuillotineMenu.podspec" \\
  || miss "missing critical file: GuillotineMenu.podspec"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 2248 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~2218d)"
else
  miss "last commit was $days_since_last days ago — artifact may be stale"
fi

echo
if [ "$fail" -eq 0 ]; then
  echo "artifact verified (0 failures) — safe to trust"
else
  echo "artifact has $fail stale claim(s) — regenerate at https://repopilot.app/r/Yalantis/GuillotineMenu"
  exit 1
fi

Each check prints ok: or FAIL:. The script exits non-zero if anything failed, so it composes cleanly into agent loops (./verify.sh || regenerate-and-retry).

GuillotineMenu is a Swift library implementing a guillotine-blade animation for iOS menu presentation—the menu slides down and rotates from the top-left corner of the screen or navigation bar, creating a cutting motion. It uses custom UIViewControllerAnimatedTransitioning to choreograph the presentation/dismissal animation with smooth scaling and rotation transforms. Simple two-tier structure: GuillotineMenu/ contains the core animator (GuillotineMenuTransitionAnimation.swift) and assets; GuillotineMenuExample/ is a complete runnable Xcode project demonstrating usage via MenuViewController and ViewController implementing UIViewControllerTransitioningDelegate. The animator is framework-agnostic and integrates via standard iOS transition protocols.

iOS app developers building custom navigation experiences who want to add a visually distinctive menu animation without building the transition choreography from scratch. Specifically useful for teams wanting polished, branded menu interactions beyond standard UIMenuController or side-drawer patterns.

Moderately mature: this is a polished open-source library from Yalantis (a reputable iOS agency) with clean API design and working example app. However, the repo shows minimal recent activity (no visible recent commits or releases in the snippet), and it targets Swift 5.0+ with iOS 8.0+ support—suggesting it may not be actively maintained for latest iOS versions. Production-ready for iOS 8-13 era apps, but likely needs maintenance for modern iOS.

Standard open source risks apply.

No visible active development from the provided data. The repo appears to be in maintenance mode with no recent PRs, commit activity, or ongoing issues mentioned in the file listing.

Clone the repo: git clone https://github.com/Yalantis/GuillotineMenu.git. For CocoaPods users, add pod 'GuillotineMenu' to Podfile and run pod install. To run the example: open GuillotineMenuExample/GuillotineMenuExample.xcodeproj in Xcode 10+ and build for iOS 8.0+.

Daily commands: Open GuillotineMenuExample/GuillotineMenuExample.xcodeproj in Xcode 10+, select a simulator or device target (iOS 8.0+), and press Cmd+R. The example app presents a menu from the top-left corner when tapping the menu button in the navigation bar.

• GuillotineMenu/GuillotineMenuTransitionAnimation.swift — Core animation engine that implements the guillotine transition logic; all menu interactions depend on this single file.
• GuillotineMenuExample/GuillotineMenuExample/ViewController.swift — Entry point demonstrating how to instantiate and trigger the guillotine menu transition from a standard view controller.
• GuillotineMenuExample/GuillotineMenuExample/MenuViewController.swift — Menu view controller that receives the transition animation; shows expected structure for the destination menu UI.
• GuillotineMenuExample/GuillotineMenuExample/AppDelegate.swift — Application setup and root window configuration; required for understanding the full integration flow.
• GuillotineMenu.podspec — CocoaPods specification defining module exports, dependencies, and Swift version requirements for the library.
• README.md — Installation and basic usage documentation; clarifies iOS requirements (8.0+) and manual integration steps.

• GuillotineMenuTransitionAnimation (UIViewControllerAnimatedTransitioning, CABasicAnimation, CAKeyframeAnimation, UIView) — Orchestrates all animation frames; creates and coordinates CABasicAnimation objects for menu reveal effect
  • Failure mode: If animation duration is set to 0 or invalid, transition stalls; if fromPoint calculation fails, menu appears off-screen
• ViewController (UIViewController, UIViewControllerTransitioningDelegate, UIButton) — Initiates menu presentation; implements UIViewControllerTransitioningDelegate to inject custom animator
  • Failure mode: If transitioningDelegate is nil, default modal transition used; if MenuViewController not set up correctly, transition may crash
• MenuViewController (UIViewController, UIView, UIButton) — Destination view controller; receives animation; defines menu UI layout and item interactions
  • Failure mode: If menu layout is missing or views not properly configured, animated elements may not render or be interactive

• User interaction (button tap) → ViewController — Button action triggers presentViewController call
• ViewController → UIViewControllerTransitioningDelegate — Delegate method called to provide custom animator
• UIViewControllerTransitioningDelegate → GuillotineMenuTransitionAnimation — animationControllerForPresentedController returns animator instance
• GuillotineMenuTransitionAnimation → Core Animation (CABasicAnimation) — Animator creates and configures animations for position, scale, and opacity
• Core Animation → MenuViewController — Animation frames applied to menu view layers during transition
• MenuViewController → User — Animated menu now visible and ready for interaction

Integrate Guillotine Menu into a new view controller

1. Copy GuillotineMenuTransitionAnimation.swift to your project (GuillotineMenu/GuillotineMenuTransitionAnimation.swift)
2. Create a destination MenuViewController; see example structure in MenuViewController.swift (GuillotineMenuExample/GuillotineMenuExample/MenuViewController.swift)
3. In your ViewController, make it conform to UIViewControllerTransitioningDelegate and return GuillotineMenuTransitionAnimation() from animationControllerForPresentedController method (GuillotineMenuExample/GuillotineMenuExample/ViewController.swift)
4. Present the menu view controller with modalPresentationStyle set to custom and transitioningDelegate set to self (GuillotineMenuExample/GuillotineMenuExample/ViewController.swift)

Customize animation parameters (timing, direction, scale)

1. Open GuillotineMenuTransitionAnimation.swift and locate the animateTransition method (GuillotineMenu/GuillotineMenuTransitionAnimation.swift)
2. Adjust CABasicAnimation duration (default ~0.5s) and CAKeyframeAnimation keyTimes to change timing (GuillotineMenu/GuillotineMenuTransitionAnimation.swift)
3. Modify the fromPoint property (currently top-left corner) or scale factors to change animation origin and scale behavior (GuillotineMenu/GuillotineMenuTransitionAnimation.swift)

Update the example app with your custom menu items and styling

1. Edit MenuViewController to add your custom menu buttons and layout (GuillotineMenuExample/GuillotineMenuExample/MenuViewController.swift)
2. Replace menu icons and content images in Assets folder (GuillotineMenuExample/GuillotineMenuExample/Assets)
3. Update the storyboard or programmatically configure the main view controller appearance (GuillotineMenuExample/GuillotineMenuExample/Base.lproj/Main.storyboard)

• UIViewControllerAnimatedTransitioning — Standard iOS protocol for custom presentation animations; integrates seamlessly with UIViewController's transition system
• CABasicAnimation and CAKeyframeAnimation — Provides precise frame-by-frame control over position, scale, and opacity changes; optimized for smooth GPU-accelerated rendering
• Swift 5.0 — Modern language features for clean, type-safe code; aligns with current iOS development standards
• CocoaPods — Industry-standard dependency management; simplifies integration into existing iOS projects

• Single-file core library (GuillotineMenuTransitionAnimation.swift)

  • Why: Reduces coupling and simplifies manual integration without dependency managers
  • Consequence: Limited extensibility for advanced use cases; developers must fork or modify for significant customization

• Hard-coded animation parameters (duration, timings, origin point)

  • Why: Simpler implementation and faster to understand for example purposes
  • Consequence: Requires code modification to customize animation behavior; no runtime configuration API exposed

• No interactive gesture recognition built-in

  • Why: Focuses on polished, deterministic animation rather than complex interactive logic
  • Consequence: Developers must add tap/swipe handlers separately; menu interactions not dismissible via gesture

• Does not provide interactive gesture dismissal (swipe-to-close); animation is presentation-only
• Does not handle nested view controller hierarchies or container controllers
• Does not include navigation between menu items; transitions are purely visual
• Does not support runtime customization of animation parameters via properties
• Not compatible with iOS 7 or earlier; requires iOS 8.0+

• Magic numbers in animation configuration (Medium) — GuillotineMenu/GuillotineMenuTransitionAnimation.swift: Hard-coded values for animation duration, scales, and timing curves are not exposed as configurable properties; makes customization difficult without code modification
• No error handling in transition animator (Low) — GuillotineMenu/GuillotineMenuTransitionAnimation.swift: animateTransition method does not validate input context or handle edge cases; could fail silently if frame calculations produce invalid values
• Tight coupling to view hierarchy assumptions — GuillotineMenu/GuillotineMenuTransitionAnimation.swift: Animation logic assumes specific view and layer structure; breaks if MenuViewController uses unexpected view hierarchies or custom layer configurations

No visible hidden traps, but note: (1) GuillotineMenu protocol conformance is mandatory—the animator assumes menuButton and titleView properties exist and will crash if missing; (2) modalPresentationStyle must explicitly be set to .custom, not the default; (3) transitioningDelegate must be set on the menu view controller before present(), not on the presenting controller; (4) supportView and presentButton must be assigned before present() or animation will use incorrect geometry.

• UIViewControllerAnimatedTransitioning Protocol — Core to understanding how GuillotineMenuTransitionAnimation plugs into iOS's view controller presentation system; required reading to modify or extend the animator.
• CABasicAnimation and CATransform3D — The guillotine cutting motion is built on Core Animation's transform primitives (scale, rotation, translation); essential to tweak timing and easing.
• UIViewControllerTransitioningDelegate — The glue connecting the presenter to the animator; you must implement this to wire GuillotineMenuTransitionAnimation into your view controller lifecycle.
• Custom Modal Presentation Style (.custom) — GuillotineMenu requires modalPresentationStyle = .custom to bypass iOS's default dimming and gesture handling, allowing full animator control.
• Affine and 3D Transform Composition — The animator stacks rotation, scaling, and translation transforms to create the cutting blade effect; understanding composition order matters for visual accuracy.
• UIView Snapshotting and Animating Container Views — The animator likely uses view snapshots and a temporary container to animate the menu without affecting the original view hierarchy during transition.

• material-components/material-components-ios — Google's Material Design for iOS includes transition animations and menu components with similar custom animator patterns.
• Ramotion/animated-tab-bar — Another Ramotion animation library (similar team ethos) demonstrating custom UIView and UIViewController transition choreography in Swift.
• Yalantis/Side-Menu.iOS — Yalantis' own alternative menu library offering a different animation style for developers exploring menu UX options.
• Interactive-Tutorials/Walkthroughs — Complements GuillotineMenu by showing how to layer custom transitions with interactive gesture recognizers for dismissal.

To work on one of these in Claude Code or Cursor, paste: Implement the "<title>" PR idea from CLAUDE.md, working through the checklist as the task list.

Add Swift Package Manager (SPM) support via Package.swift

The repo currently only supports CocoaPods installation, but SPM is the modern standard for Swift dependency management. Adding a Package.swift manifest would allow developers using SPM to easily integrate GuillotineMenu without CocoaPods overhead. This is a minimal, high-value addition that requires creating one file.

• [ ] Create Package.swift at the root with proper package definition pointing to GuillotineMenu/ as the library target
• [ ] Verify the manifest correctly declares Swift 5.0+ as the minimum version and excludes example/test files
• [ ] Test SPM integration locally with a test project to ensure the library resolves and builds correctly
• [ ] Update README.md with SPM installation instructions

Complete the truncated 'Manual Installation' section in README.md

The README.md has an incomplete Manual Installation section (ends with 'You mus'). This should provide step-by-step instructions for developers who prefer not to use CocoaPods. This is a quick win that removes friction for contributors following setup instructions.

• [ ] Complete the sentence and provide clear steps (copy GuillotineMenu.swift to project, link framework, etc.)
• [ ] Reference the specific files involved: GuillotineMenu/GuillotineMenuTransitionAnimation.swift and GuillotineMenu/ic_menu@3x.png
• [ ] Add a note about iOS 8.0+ and Swift 5.0 requirements in the manual section
• [ ] Verify instructions match what's shown in GuillotineMenuExample/ setup

Add GitHub Actions CI workflow for Swift build and tests

The repo lacks any CI/CD pipeline (no .github/workflows/ directory). Adding a GitHub Actions workflow to build the library and run the example project on each PR would catch regressions early and signal quality to users. This is specific to Swift/iOS and relatively straightforward.

• [ ] Create .github/workflows/swift.yml to run on push and pull_request events
• [ ] Configure the workflow to: checkout code, setup Xcode environment, build GuillotineMenu target from GuillotineMenuExample.xcodeproj, and run any available unit tests
• [ ] Test the workflow by pushing to a feature branch and verifying it runs successfully
• [ ] Update CONTRIBUTING.md to reference the CI checks that must pass before merging

• Add unit tests for GuillotineMenuTransitionAnimation.swift covering presentation and dismissal modes with different animationDuration values to ensure transform math is correct.
• Create comprehensive API documentation in the README with before/after screenshots showing how supportView and presentButton affect the animation origin point.
• Refactor the example app to use modern SwiftUI-compatible patterns and add a second example showing menu presentation from a non-navigation-bar custom view.

The GuillotineMenu codebase demonstrates a strong security posture. As a pure Swift UI animation library with no external dependencies, backend integrations, or data processing, it has minimal attack surface. The primary concerns identified are maintenance-related rather than critical security issues: outdated development tool requirements and incomplete documentation. No hardcoded credentials, injection vulnerabilities, or infrastructure misconfigurations were detected. The library is focused on UI/UX animation and does not handle sensitive data, making it inherently low-risk from a security perspective.

• Low · Incomplete README Installation Instructions — README.md. The README.md file contains incomplete installation instructions (text cuts off at 'You mus'). While not a direct security vulnerability, incomplete documentation can lead to improper installation or usage patterns. Fix: Complete the README.md installation section with full and accurate instructions.
• Low · Outdated Swift and Xcode Requirements — README.md and GuillotineMenu.podspec. The project specifies minimum requirements of Xcode 10 and Swift 5.0, which are significantly outdated (released in 2018-2019). Outdated toolchains may not include the latest security patches and compiler-level protections. Fix: Update minimum Swift version to 5.5+ and Xcode to version 13+ to ensure access to modern security features and bug fixes.

LLM-derived; treat as a starting point, not a security audit.

• Open issues — current backlog
• Recent PRs — what's actively shipping
• Source on GitHub

Generated by RepoPilot. Verdict based on maintenance signals — see the live page for receipts. Re-run on a new commit to refresh.