StageFright Community

A clean, modern, modular desktop application that reduces administrative overhead for community performing arts groups. Built with .NET MAUI and Blazor Hybrid, featuring double-entry financial tracking and attendance management with a plugin-friendly architecture.

I had this project planned many years ago, and life got in the way. As AI improved and "vibe coding" became a thing, I thought I would revive this project, and use it as a testbed for AI code generation.

All code has been 100% generated by Claude Code. I have read over and checked every line. Anything I found I did not like, I corrected by refining the prompts and being very specific about how I wanted the code to work. All the code itself was written/changed by Claude.

I also made the decision to use Github SpecKit to guide the AI towards spec driven design.

To contribute to this project, I encourage you to use the Github SpecKit workflow, SpecKit Companion and an AI agent, but this is not a requirement. Claude Code is the agent I prefer to use, but you are free to use other agents (or no agents at all).

Create an issue for the bug fix/change/update/feature. Don't just start coding it without approval. Pull requests not directly linked to an issue will be rejected.

The master branch will always contain the code for the most recent release. The dev branch will contain the latest code updates, features and changes that are being assembled for the next release. Only pull requests against the dev branch will be accepted.

Make a fork of this repo and use that as your private scratch pad. When you are ready for a review and merge, create a pull request to dev.

Tools used

• Claude Code -Sonnet 5 model (https://www.anthropic.com/claudecode)
• Github Spec Kit (https://github.com/github/spec-kit)
• SpecKit Companion (https://github.com/alfredoperez/speckit-companion)

Vision

StageFright Community delivers a robust platform for managing members, finances, events, and attendance with:

• Clean, maintainable code following SOLID principles
• Layered architecture with module slices for independent feature development (see Architecture Guide)
• Dashboard-driven interface for intuitive feature discovery
• Accurate, double-entry financial tracking with immutable transaction records
• Extensible plugin system for community-specific customization
• Modern, compact UI design minimizing whitespace and visual clutter

Quick Start

Prerequisites

• .NET 10.0 SDK (with the MAUI workload: dotnet workload install maui)
• Visual Studio 2022 (recommended) or Visual Studio Code with the C# Dev Kit
• Windows 10 (build 19041+) or macOS (Mac Catalyst)

Building the Project

# Restore dependencies (installs the MAUI workload first if needed)
dotnet workload install maui
dotnet restore

# Build the solution
dotnet build

# Run the application
dotnet run --project src/StageFright.App/

Running Tests

# Run all tests
dotnet test

# Run a specific test project
dotnet test tests/StageFright.Core.Tests/

See SETUP.md for full developer setup, database/migration commands, and CI details.

Architecture

Layered Architecture with Module Slices

Rather than a per-module Domain/Application/Infrastructure/UI vertical slice, this is a layered solution — one project per architectural layer, with each business capability organized as a folder inside StageFright.Core:

src/
├── StageFright.App/          # MAUI Blazor Hybrid host — composition root only
├── StageFright.Core/         # Entities, enums, exceptions, contracts, and
│   └── Modules/<Name>/       #   per-module services + request/response DTOs + menu provider
├── StageFright.Data/         # Centralized DAL — one repository per entity
├── StageFright.Plugins.Contracts/  # Extension-point interfaces
├── StageFright.Reports/      # Report pipeline
└── StageFright.UI/           # All Blazor UI (pages, dashboard tiles, shared components)

Current modules: Agm, AuditTrail, Dashboard, Events, Finance, Members, Rehearsals, Settings.

Key Principles:

• No MediaTr or CQRS — modules use direct service injection and standard patterns
• Repositories are centralized in StageFright.Data, not module-owned — a deliberate deviation from pure vertical-slice architecture (one shared SQLite database)
• Explicit DI registration — every service/repository/provider is registered by hand in MauiProgram.cs; there's no assembly-scanning auto-discovery for in-solution types
• Dashboard tiles — each module defines how it appears on the dashboard, via a provider living in StageFright.UI

See Architecture Guide for the full picture.

Dashboard Tile System

The dashboard is the primary user interface for feature discovery. Each module exposes functionality through dashboard tiles that can contain:

• Summary metrics and information
• Interactive charts and graphs
• Quick-action buttons
• Activity feeds and status indicators

Tiles opt into one of four grid footprints (OneByOne default, OneByTwo, TwoByOne, TwoByTwo) and load in parallel — a failing tile shows "Unable to load" without breaking the dashboard.

Settings System

Configuration and preferences are managed through the Settings page (/settings), organized into tabs:

• Built-in tabs (General, Tax, Committee, Event Types, Backup & Restore) are hardcoded directly in the Settings page — not contributed by modules
• Plugin-contributed tabs implement ISettingsTabProvider and are appended after the built-in tabs, discovered at runtime

Core Application Settings (General tab):

• Organization/Group Name
• Annual Membership Fee
• Rehearsal/Event Fee
• Membership Renewal Due Date

Navigation Menu System

Navigation renders as a fixed vertical sidebar (not a top nav bar). Each module defines its own menu items via IMenuItemProvider, registered explicitly (not auto-discovered) in MauiProgram.cs.

• Module Menu Items — Each module contributes menu items for feature navigation
• Icon Support — Sidebar icons are Bootstrap Icons inlined as CSS masks
• Sub-menus — Expandable/collapsible groups, auto-expanding while a child route is active
• Dynamic Badges — Real-time notification counts (e.g., "5" pending items)
• Settings Always Last — Settings menu item is reserved and always appears at the end

Example Navigation:

Dashboard
├── Members
├── Rehearsals
├── Events
├── Finance
├── Agm
├── AuditTrail
... [other modules] ...
└── Settings

See ARCHITECTURE.md § Navigation for implementation details.

UI Design

The application follows the "Midnight Glass" design system — a glassmorphism theme of soft gradient-orb backgrounds, frosted/blurred panels, and a condensed display typeface (Saira Semi Condensed), defined as CSS custom properties in StageFright.App/wwwroot/app.css:

• Minimal whitespace — compact layouts using Bootstrap spacing utilities
• Design tokens — every color is a --sf-* custom property, with light/dark variants
• Consistent components — RadzenDataGrid for tables, BorderedListBox for bordered lists, RadzenSwitch for toggles
• Accessible — keyboard-navigable, screen-reader compatible

See UI Component Style Guide for detailed design standards and component examples.

Development Guidelines

Testing Requirements

All code must be tested. Testing is a first-class citizen with mandatory coverage requirements:

• Every reachable code path must have automated tests before merge
• Unit tests (xUnit v3 + NSubstitute) for business logic and component behavior
• Integration tests (real SQLite) for service interactions
• UI tests (bUnit) for Blazor components and user-facing functions
• Tests must cover: success paths, validation failures, exceptions, boundary conditions, and state transitions

Code Quality Standards

• Follow SOLID principles (Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion)
• Use custom domain exceptions at architectural boundaries
• Implement soft-delete pattern for data preservation (financial records — Fee, Payment, Transaction — are immutable and exempt)
• One class/interface/record/struct/enum per file, file name matching the type exactly

Custom Exceptions

All exceptions crossing architectural boundaries must use one of the project-defined custom exceptions (StageFright.Core/Exceptions/):

• DataAccessException
• EntityNotFoundException
• DuplicateEntityException
• ConcurrencyException
• DataIntegrityException
• ValidationException
• GLBalanceException
• ReconciliationException
• ImportException
• PluginLoadException

Every one shares one constructor shape: (message, entityType, operationContext, entityId = null, innerException = null). Raw framework exceptions must be translated at boundaries.

Constitution & Governance

This project operates under the Spec Kit Constitution (version 2.6.0), which defines:

• Architectural patterns and standards
• Testing requirements and coverage expectations
• Data preservation and soft-delete rules
• Module organization and plugin architecture
• Specification structure and quality gates

See Constitution for the complete governance framework.

Contributing

Contributions are welcome! Please read CONTRIBUTING.md for:

• Development workflow
• Solution structure guidelines
• Creating new features with specifications
• Testing and quality requirements
• Code review process
• Commit conventions

Technology Stack

• Framework: .NET MAUI with Blazor Hybrid (target: net10.0-windows10.0.19041.0 / net10.0-maccatalyst)
• Language: C# 14
• UI: Blazor components, Radzen Blazor (Radzen.Blazor), BlazorBootstrap (Blazor.Bootstrap)
• Platforms: Windows desktop, macOS desktop
• Testing: xUnit v3, bUnit, NSubstitute
• Logging: Serilog + OpenTelemetry
• Data: Entity Framework Core against SQLite (Microsoft.EntityFrameworkCore.Sqlite)
• Reports: QuestPDF (PDF), CsvHelper (CSV)

Key Features

• Member Management — Add, track, and manage member information
• Financial Tracking — Double-entry GL, immutable transaction records, fee tracking, payment processing, bank reconciliation
• Event & Rehearsal Scheduling — Schedule rehearsals and events, manage attendance
• AGM & Committee — Annual general meeting workflow and committee term/position tracking
• Reporting — Ten built-in reports (Income Statement, Trial Balance, Balance Sheet, General Ledger, and more) exported to PDF or CSV
• Dashboard — At-a-glance feature access through modular, resizable dashboard tiles
• Plugin System — Five extension points (dashboard tiles, settings tabs, menu items, reports, data access) for external assemblies

License

[Specify your license here]

Support

• Documentation: docs/ folder
• Issues: GitHub Issues
• Questions: GitHub Discussions

Roadmap

• MVP — Core member, financial, and event modules (shipped)
• Finance Expansion — Double-entry GL, bank reconciliation, generic sales tax (shipped)
• Setup Wizard & Onboarding — Guided first-run configuration (shipped)
• Plugin Ecosystem — Third-party plugin distribution and discovery (infrastructure in place; ecosystem growth ongoing)
• Cloud Sync & Backup — Optional cloud backup/sync
• Multi-Discipline Support — Beyond performing arts groups, plus advanced reporting