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/marcosgriselli/ViewAnimator 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 2y ago

• 17 active contributors
• MIT licensed
• Tests present
• ⚠ Stale — last commit 2y ago
• ⚠ Concentrated ownership — top contributor handles 79% of recent commits
• ⚠ No CI workflows 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 marcosgriselli/ViewAnimator repo on your machine still matches what RepoPilot saw. If any fail, the artifact is stale — regenerate it at repopilot.app/r/marcosgriselli/ViewAnimator.

What it runs against: a local clone of marcosgriselli/ViewAnimator — 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 marcosgriselli/ViewAnimator | 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 ≤ 800 days ago | Catches sudden abandonment since generation |

#!/usr/bin/env bash
# RepoPilot artifact verification.
#
# WHAT IT RUNS AGAINST: a local clone of marcosgriselli/ViewAnimator. If you don't
# have one yet, run these first:
#
#   git clone https://github.com/marcosgriselli/ViewAnimator.git
#   cd ViewAnimator
#
# 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 marcosgriselli/ViewAnimator and re-run."
  exit 2
fi

# 1. Repo identity
git remote get-url origin 2>/dev/null | grep -qE "marcosgriselli/ViewAnimator(\\.git)?\\b" \\
  && ok "origin remote is marcosgriselli/ViewAnimator" \\
  || miss "origin remote is not marcosgriselli/ViewAnimator (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 "Sources/ViewAnimator.swift" \\
  && ok "Sources/ViewAnimator.swift" \\
  || miss "missing critical file: Sources/ViewAnimator.swift"
test -f "Sources/Animation.swift" \\
  && ok "Sources/Animation.swift" \\
  || miss "missing critical file: Sources/Animation.swift"
test -f "Sources/Animatable.swift" \\
  && ok "Sources/Animatable.swift" \\
  || miss "missing critical file: Sources/Animatable.swift"
test -f "Example/iOS/ViewControllers/ViewController.swift" \\
  && ok "Example/iOS/ViewControllers/ViewController.swift" \\
  || miss "missing critical file: Example/iOS/ViewControllers/ViewController.swift"
test -f "Sources/CABasicAnimation+Extension.swift" \\
  && ok "Sources/CABasicAnimation+Extension.swift" \\
  || miss "missing critical file: Sources/CABasicAnimation+Extension.swift"

# 5. Repo recency
days_since_last=$(( ( $(date +%s) - $(git log -1 --format=%at 2>/dev/null || echo 0) ) / 86400 ))
if [ "$days_since_last" -le 800 ]; then
  ok "last commit was $days_since_last days ago (artifact saw ~770d)"
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/marcosgriselli/ViewAnimator"
  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).

ViewAnimator is a Swift library that enables complex UIView animations with single-line syntax, supporting entire views, UITableView/UICollectionView cells, UIStackView subviews, and nested view hierarchies. It abstracts Core Animation boilerplate into declarative animation chains that can be applied to individual views or recursively across container views without manual timing or sequencing logic. Straightforward framework structure: the core animation logic lives in unnamed Swift source files (39.7 KB total), Examples/iOS contains a reference app with AppDelegate and storyboards, and Example assets demonstrate use cases (table, collection, stack animations). No monorepo or package separation—single-target CocoaPods package.

iOS/tvOS developers building feature-rich apps who need to animate view hierarchies (tables, collections, stacks) during data load, transitions, or user interactions without writing verbose Core Animation code. Designers and developers collaborating on polished UX who want one-line animation APIs instead of 50 lines of CABasicAnimation setup.

Actively maintained, production-ready library with CocoaPods/Carthage distribution, Swift 4.2+ support, and presence across iOS/tvOS platforms. No commit recency data visible, but the clean API design and multiple example assets suggest mature, stable code. Codebeat badge indicates ongoing quality monitoring.

Single maintainer (marcosgriselli) creates maintenance risk if unavailable. No visible test coverage metrics or CI pipeline configuration (no .yml files shown) is a red flag for regression testing. Dependency on Core Animation internals means iOS version compatibility must be carefully managed. Last commit date unknown, making it impossible to assess staleness.

No specific commit or PR data visible in provided file list. Repository structure suggests examples are maintained (multiple image assets at different densities), but current development velocity is unknown. README indicates support for Swift 4.2, so may not track latest Swift versions.

git clone https://github.com/marcosgriselli/ViewAnimator.git
cd ViewAnimator
pod install
# Open Example/iOS project in Xcode
open Example/iOS/Example.xcworkspace

Daily commands: Open Example/iOS/Example.xcworkspace in Xcode (CocoaPods project), build for iOS simulator/device. No CLI tools; run via Xcode IDE or xcodebuild for CI. CocoaPods setup via pod install is required first.

• Sources/ViewAnimator.swift — Core library entry point defining the main animation API and orchestration logic that all animations flow through
• Sources/Animation.swift — Fundamental animation model defining animation parameters, timing, and application logic across all view types
• Sources/Animatable.swift — Protocol that enables any UIView to become animatable; essential for understanding the framework's extension architecture
• Example/iOS/ViewControllers/ViewController.swift — Primary example demonstrating the one-line animation API and how to integrate ViewAnimator into real apps
• Sources/CABasicAnimation+Extension.swift — Core animation execution layer translating ViewAnimator models into native Core Animation primitives
• Sources/CGAffineTransform+Animation.swift — Transform utilities defining the animation preset types (rotate, scale, translate) that form the library's animation vocabulary

• ViewAnimator (orchestrator) (Swift protocol extension, CATransaction) — Public API entry point; converts high-level animation requests into Core Animation primitives and manages execution
  • Failure mode: Animations don't execute if CATransaction or view layer is invalid
• Animation (model) (Swift struct, Codable (optional)) — Immutable animation descriptor carrying duration, delay, timing curve, and transform; acts as configuration carrier
  • Failure mode: Invalid duration/delay values silently clamped or ignored by Core Animation
• CABasicAnimation extension (Core Animation, CAMediaTimingFunction) — Bridging layer converting ViewAnimator animations to native Core Animation; handles fromValue/toValue setup
  • Failure mode: Animation ignores transforms if layer geometry is zero or invalid
• CGAffineTransform presets (CoreGraphics, linear algebra) — Enumeration of common transform combinations (scale, rotate, translate, perspective); composable via multiplication
  • Failure mode: Degenerate transforms (scale 0) produce undefined behavior; not validated at build time

• UIViewController/User code → ViewAnimator.animate(views, animations) — Developer supplies array of views and Animation objects
• Animation array → CABasicAnimation creation — Each Animation model mapped to CABasicAnimation with fromValue/toValue transforms
• CABasicAnimation objects → CATransaction batch — All animations added to implicit or explicit Core Animation transaction
• Core Animation render thread → UIView.layer.presentation() — Frame-by-frame interpolation of layer transform during animation duration
• Animation completion → Completion closure on main thread — After duration+delay elapses, optional completion handler fired with finished flag

Add a new animation preset

1. Define the transform in Sources/CGAffineTransform+Animation.swift by adding a static computed property that returns a CGAffineTransform (Sources/CGAffineTransform+Animation.swift)
2. Add the preset case to the Animation enum's initializer pattern in Sources/Animation.swift (Sources/Animation.swift)
3. Test with one-liner in Example/iOS/ViewControllers/ViewController.swift: UIView.animate(myView, animations: [.yourNewPreset()]) (Example/iOS/ViewControllers/ViewController.swift)

Animate a new collection of views (TableView/CollectionView cells)

1. Create a custom cell class in Example/iOS/Views/Cells/ extending UITableViewCell or UICollectionViewCell (Example/iOS/Views/Cells/TableViewCell.swift)
2. In cellForRowAt/cellForItemAt, call UIView.animate() with your cell and animation array plus optional delay parameter (Example/iOS/ViewControllers/TableViewController.swift)
3. Use indexPath.row to calculate staggered delays via Animation(delay: TimeInterval(indexPath.row) * 0.1, ...) (Example/iOS/ViewControllers/CollectionViewController.swift)

Create a custom animation with timing and completion

1. Instantiate Animation struct with duration, delay, timingFunction, and optional completion closure in Sources/Animation.swift (Sources/Animation.swift)
2. Pass animation array to ViewAnimator.animate() in Sources/ViewAnimator.swift with your custom timing parameters (Sources/ViewAnimator.swift)
3. Test in Example/iOS/ViewControllers/ViewController.swift by calling UIView.animate() with your custom animations (Example/iOS/ViewControllers/ViewController.swift)

• Swift 4.2 — Modern language features enable clean protocol-based extension pattern for UIView without subclassing
• Core Animation (CABasicAnimation) — Lowest-level GPU-accelerated animation framework; essential for smooth, performant transform and opacity animations
• Protocol-oriented design (Animatable protocol) — Allows extending existing UIView without subclassing; enables clean one-liner API and composition
• Closure-based completion handlers — Provides callback mechanism for coordinating animations and triggering subsequent logic

• One-liner animation API via UIView extension

  • Why: Maximum developer ergonomics and discoverability; easy to adopt in existing codebases
  • Consequence: Global UIView namespace pollution; requires careful naming to avoid conflicts with Apple frameworks

• Direct CGAffineTransform presets rather than dynamic composition

  • Why: Simple, predictable API surface; most common animations covered by presets
  • Consequence: Limited flexibility for exotic transforms; complex animations require manual Core Animation setup

• Synchronous animation chaining via delay parameter

  • Why: Simple implementation; works for sequential animations in most UI contexts
  • Consequence: Not suitable for complex async orchestration; no built-in dependency graph or cancellation

• Real-time motion capture or gesture-driven animations (static preset-based only)
• Complex 3D perspective transforms beyond basic CATransform3D
• Explicit animation cancellation or interruption API
• macOS or watchOS support (iOS and tvOS only per README)

• Global UIView extension pollution (Low) — Sources/ViewAnimator.swift (entire file): All animation methods added directly to UIView via extension; creates ambiguity and potential conflicts with other libraries extending UIView
• Synchronous staggered delays via manual TimeInterval arithmetic (Low) — Example/iOS/ViewControllers/CollectionViewController.swift: Staggered animations computed naively as indexPath.row * constant; fragile and error-prone for dynamic cell counts
• No explicit animation cancellation (Medium) — Sources/ViewAnimator.swift: Animations committed to Core Animation with no built-in way to cancel mid-flight; consumers must manually removeAllAnimations() on layer
• Silent transform clamping on invalid values — Sources/CGAffineTransform+Animation.swift: Degenerate transforms (e.g., scale 0, NaN duration) silently accepted and passed to Core Animation without validation or warning

CocoaPods dependency required before opening .xcworkspace; opening .xcodeproj directly will fail. No visible test suite means manual testing against multiple iOS versions is necessary. Core Animation behavior differs subtly across iOS versions (iPhone/iPad/tvOS), so simulator testing alone is insufficient. Animation timing may conflict with system transitions if not properly configured with CATransaction.

• Core Animation CAAnimationGroup — ViewAnimator chains animations via CAAnimationGroup and CATransaction; understanding group composition and timing is essential to predict actual animation behavior
• Recursive view traversal (view.subviews iteration) — Core feature: animating nested hierarchies (table cells, stack subviews) requires depth-first/breadth-first traversal of UIView trees with proper timing offsets
• CABasicAnimation keyframe paths — ViewAnimator likely uses fromValue/toValue pairs for position, opacity, scale; understanding keyframe semantics prevents animation discontinuities
• UIView extension methods — ViewAnimator adds methods directly to UIView, UITableView, etc. via Swift extensions; this pattern is core to the one-line API design
• Animation timing curves (easing functions) — CAMediaTimingFunction (linear, easeIn, easeOut, easeInEaseOut) control perceived animation smoothness; ViewAnimator likely exposes these as parameters
• CocoaPods pod specification (.podspec) — ViewAnimator is distributed as a CocoaPod; understanding .podspec syntax (source, dependencies, platforms) is needed to modify or fork the package

• lkzhao/Hero — Direct inspiration cited in README; Hero provides page/transition animations that ViewAnimator complements for view hierarchy animations
• Ramotion/animated-tab-bar — Similar goal of one-line view animations in iOS; common alternative for tab bar and component animations
• realm/realm-swift — Often used alongside ViewAnimator to animate data changes in UITableView/UICollectionView when Realm models update
• rxswiftcommunity/RxAnimated — Reactive extension library for animating view properties; complements ViewAnimator for reactive animation chains

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 unit tests for ViewAnimator core animation logic

The repo has example apps but no visible test files in the structure. ViewAnimator's core animation functionality (the main value proposition) lacks test coverage. This is critical for a library that manipulates UI animations—tests ensure animations behave consistently across iOS/tvOS versions and don't regress.

• [ ] Create Tests/ directory with unit tests for animation timing, delays, and view transformation logic
• [ ] Add tests for edge cases: empty view arrays, invalid durations, concurrent animations
• [ ] Test both UIView and UIViewController animation extensions
• [ ] Reference Example/iOS/ViewControllers/*.swift to understand animation usage patterns and test those scenarios

Add GitHub Actions CI workflow for Swift linting and test automation

The repo has .github/CODE_OF_CONDUCT.md and .github/ISSUE_TEMPLATE.md but no CI workflow files (.github/workflows/). For an active open-source library, automated testing on PRs is essential to maintain code quality and prevent regressions across Swift versions and iOS/tvOS targets.

• [ ] Create .github/workflows/ci.yml to run on pull_request and push events
• [ ] Configure matrix testing for iOS 12+ and tvOS 12+ (based on badge showing iOS/tvOS support)
• [ ] Include swift-lint or similar for code style consistency
• [ ] Run unit tests (from first PR suggestion) and example app build validation
• [ ] Add SwiftFormat or equivalent to catch formatting issues early

Document animation API with code examples in dedicated ANIMATIONS.md

The README shows a banner but lacks detailed API documentation. Example code exists in Example/iOS/ViewControllers/*.swift but isn't surfaced in docs. New contributors and users need clear examples of animation types, custom animations, and chaining—this is the core value of the library.

• [ ] Create ANIMATIONS.md documenting all animation types with code snippets from Example/iOS/ViewControllers/ViewController.swift
• [ ] Add examples for: sequential animations, spring animations, rotation/scale/alpha combinations
• [ ] Document CustomAnimation protocol and how to create custom animations (referencing Example/iOS/Views/Designable.swift pattern)
• [ ] Include timing and delay parameter documentation with visual timing diagrams
• [ ] Add troubleshooting section for common animation timing issues

• Add unit tests for animation timing and stagger calculations in Example/iOS scenarios—currently no Tests/ folder visible, so create test cases for UITableViewCell batch animations at various delay intervals
• Document API surface with inline code examples in source files (e.g., add MARK comments showing UIView.animate() vs ViewAnimator.animate() comparison) since public API is inferred but not explicitly documented in repo
• Expand Example app with a new UIStackView animation demo (currently assets suggest table/collection focus)—add a dedicated view controller showing arrangedSubviews staggered animations

The ViewAnimator library shows a reasonable security posture for a UI animation library with no critical vulnerabilities identified from the available file structure analysis. However, the outdated Swift 4.2 reference and lack of visible security policy documentation indicate areas for improvement. The project is primarily a UI framework without apparent database operations, authentication, or network communication, which reduces attack surface. No hardcoded secrets, suspicious dependencies, or obvious injection points were detected. Main recommendations are updating to modern Swift versions and establishing security communication channels. A complete source code review is needed for comprehensive assessment.

• Low · Outdated Swift Version Referenced — README.md badge. The README badge indicates Swift 4.2 compatibility, which is deprecated and no longer supported by Apple. This suggests the project may not be actively maintained and could contain unpatched vulnerabilities. Fix: Update the project to support modern Swift versions (5.x+) and verify all dependencies are compatible with current Swift releases.
• Low · Missing Security Policy Documentation — Repository root. No SECURITY.md or security policy file found in the repository. This makes it difficult for security researchers to report vulnerabilities responsibly. Fix: Add a SECURITY.md file documenting responsible disclosure practices and how to report security issues privately.
• Low · Limited Code Access for Review — Source code files not provided. The provided file structure shows only directory listings and configuration files, not actual source code. Unable to perform deep analysis of potential injection vulnerabilities, insecure coding patterns, or misuse of UIKit/tvOS frameworks. Fix: Provide access to actual source code files (*.swift files in ViewAnimator folder) for comprehensive security analysis.

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.