DevdayAAVN - NFT Marketplace iOS App

A modern iOS 18+ application built with Swift 6.1 and SwiftUI, featuring a glass morphism design system and Figma-to-code integration via Model Context Protocol (MCP).

📚 Documentation

This project includes comprehensive documentation for AI-assisted development:

Core Documentation

• CLAUDE.md - Project architecture, coding guidelines, and SwiftUI patterns
• FIGMA_DESIGN_SYSTEM.md - Complete Figma-to-SwiftUI integration guide
• DESIGN_SYSTEM_QUICK_REFERENCE.md - Quick lookup for common patterns

Key Features

• ✅ Figma MCP Integration - Automated design-to-code workflow
• ✅ Type-Safe Design Tokens - Centralized design system in DesignSystem.swift
• ✅ Glass Morphism UI - Native SwiftUI material effects
• ✅ Component-Based Architecture - Reusable, composable UI components
• ✅ Swift 6 Concurrency - Modern async/await patterns with strict concurrency checking

Customization Options

These rules files are starting points - feel free to:

• ✅ Edit them to match your team's coding standards
• ✅ Delete them if you prefer different approaches
• ✅ Add your own rules for other AI tools
• ✅ Update them as new iOS APIs become available

What Makes These Rules Opinionated

• No ViewModels: Embraces pure SwiftUI state management patterns
• Swift 6+ Concurrency: Enforces modern async/await over legacy patterns
• Latest APIs: Recommends iOS 18+ features with optional iOS 26 guidelines
• Testing First: Promotes Swift Testing framework over XCTest
• Performance Focus: Emphasizes @Observable over @Published for better performance

Note for AI assistants: You MUST read the relevant rules files before making changes to ensure consistency with project standards.

Project Architecture

DevdayAAVN/
├── DevdayAAVN.xcworkspace/              # Open this file in Xcode
├── DevdayAAVN.xcodeproj/                # Xcode project
├── Config/                              # Build configuration
│   ├── Shared.xcconfig                 # Common settings
│   ├── Debug.xcconfig                  # Debug configuration
│   ├── Release.xcconfig                # Release configuration
│   └── DevdayAAVN.entitlements         # App capabilities
├── DevdayAAVN/                          # Main app target
│   ├── DevdayAAVNApp.swift             # App entry point
│   ├── ContentView.swift               # Main screen
│   ├── UIComponent/                    # 🚀 UI Components
│   │   ├── DesignSystem.swift          # Design tokens
│   │   ├── Hero/                       # Hero section
│   │   ├── Search/                     # Search components
│   │   ├── Cart/                       # Cart components
│   │   ├── NavigationBar/              # Navigation
│   │   └── NFTCard/                    # NFT card components
│   ├── Models/                         # Data models
│   │   └── NFTFeatured.swift
│   └── Resources/                      # Assets & fonts
│       ├── Assets.xcassets/            # Images & icons
│       └── Fonts/                      # Custom fonts (Orbitron)
└── Documentation/
    ├── CLAUDE.md                       # Architecture guide
    ├── FIGMA_DESIGN_SYSTEM.md          # Figma integration
    └── DESIGN_SYSTEM_QUICK_REFERENCE.md

Key Architecture Points

SwiftUI-First Design

• No ViewModels: Pure SwiftUI state management with @State and @Observable
• Component Composition: Complex UIs built from smaller, reusable components
• Design Tokens: Centralized design system for consistency
• MCP Integration: Figma designs converted to SwiftUI via Model Context Protocol

Design System Structure

• DesignSystem.swift: Type-safe tokens for spacing, colors, typography, etc.
• Component Folders: Each major UI section in its own folder with subcomponents
• Glass Morphism: Native .ultraThinMaterial effects throughout
• Responsive Layouts: GeometryReader for adaptive sizing

Building & Running

Using Makefile (Recommended)

The project includes a comprehensive Makefile for all build operations:

# Show all available commands
make help

# Build the project
make build              # Build in Debug mode
make build-release      # Build in Release mode
make compile            # Quick compile check

# Run tests
make test               # Run all tests
make test-unit          # Run unit tests only
make test-ui            # Run UI tests only

# Clean & maintenance
make clean              # Clean build artifacts
make clean-deep         # Deep clean including derived data
make reset              # Reset package dependencies

# Project information
make info               # Show project details
make schemes            # List available schemes
make devices            # List available simulators

Using Xcode

1. Open DevdayAAVN.xcodeproj in Xcode
2. Select the DevdayAAVN scheme
3. Choose a simulator or device
4. Press ⌘+B to build or ⌘+R to run

Figma Design Integration

This project uses Figma MCP (Model Context Protocol) for seamless design-to-code conversion.

Quick Workflow

1. Analyze Figma Design

   mcp__figma-dev-mode-mcp-server__get_screenshot()
   mcp__figma-dev-mode-mcp-server__get_metadata({ nodeId: "..." })
   mcp__figma-dev-mode-mcp-server__get_variable_defs()

2. Convert to SwiftUI

   • Extract design tokens → Add to DesignSystem.swift
   • Convert React/Tailwind → SwiftUI components
   • Download images → Add to Assets.xcassets

3. Build Component

   • Create data model in Models/
   • Build view in UIComponent/ComponentName/
   • Add SwiftUI preview
   • Verify with make build-debug

📖 See FIGMA_DESIGN_SYSTEM.md for complete guide

Development Notes

Code Organization

Components are organized by feature in DevdayAAVN/UIComponent/, with each major feature having its own folder containing related subcomponents.

Public API Requirements

Types exposed to the app target need public access:

public struct NewView: View {
    public init() {}
    
    public var body: some View {
        // Your view code
    }
}

Adding Dependencies

Edit UIComponent/Package.swift to add SPM dependencies:

dependencies: [
    .package(url: "https://github.com/example/SomePackage", from: "1.0.0")
],
targets: [
    .target(
        name: "UIComponent",
        dependencies: ["SomePackage"]
    ),
]

Test Structure

• Unit Tests: UIComponent/Tests/UIComponentTests/ (Swift Testing framework)
• UI Tests: DevdayAAVNUITests/ (XCUITest framework)
• Test Plan: DevdayAAVN.xctestplan coordinates all tests

Configuration

XCConfig Build Settings

Build settings are managed through XCConfig files in Config/:

• Config/Shared.xcconfig - Common settings (bundle ID, versions, deployment target)
• Config/Debug.xcconfig - Debug-specific settings
• Config/Release.xcconfig - Release-specific settings
• Config/Tests.xcconfig - Test-specific settings

Entitlements Management

App capabilities are managed through a declarative entitlements file:

• Config/DevdayAAVN.entitlements - All app entitlements and capabilities
• AI agents can safely edit this XML file to add HealthKit, CloudKit, Push Notifications, etc.
• No need to modify complex Xcode project files

Asset Management

• App-Level Assets: DevdayAAVN/Assets.xcassets/ (app icon, accent color)
• Feature Assets: Add Resources/ folder to SPM package if needed

SPM Package Resources

To include assets in your feature package:

.target(
    name: "UIComponent",
    dependencies: [],
    resources: [.process("Resources")]
)

Generated with XcodeBuildMCP

This project was scaffolded using XcodeBuildMCP, which provides tools for AI-assisted iOS development workflows.