🎯 flutter_blueprint #

Enterprise-grade Flutter app scaffolding CLI — generates production-ready Flutter projects with 43+ professional files, complete architecture, authentication patterns, error handling, storage layers, and reusable widgets. Stop wasting hours on boilerplate — start building features from day one.

📱 Important Note: This is a CLI tool that runs on your development machine (Windows, Linux, macOS) to generate Flutter projects. The generated projects support ALL platforms: Android, iOS, Web, and Desktop. The CLI itself uses terminal-based UI libraries and thus only runs on desktop platforms, but the apps it creates work everywhere!

🚀 Why flutter_blueprint? #

flutter_blueprint is not just a template — it's a smart code generator that creates production-grade architecture tailored to your choices.

✨ Features #

Core Features #

Professional Add-ons (What Makes It Pro) #

DevOps Integration (NEW in v0.5.0!) #

📦 Installation #

Global Activation (Recommended) #

dart pub global activate flutter_blueprint

Then use it anywhere:

flutter_blueprint init my_app

Local Execution #

dart run flutter_blueprint init my_app

🎬 Quick Start #

✨ Interactive Wizard Mode (Recommended) #

Just run without arguments for a beautiful guided experience:

flutter_blueprint init

What happens:

🎯 Welcome to flutter_blueprint!
   Let's create your Flutter app with professional architecture.

✔ 📱 App name · my_awesome_app

✔ 🎯 Choose state management · provider
   • Provider (ChangeNotifier, easy to learn)
   • Riverpod (Compile-time safe, better testability) ← NEW!
   • Bloc (Event-driven, coming soon)
   [Use ↑↓ arrow keys, Enter to select]

✔ ✨ Select features to include (use space to select, enter to confirm)
   ✓ Theme system (Light/Dark modes)
   ✓ Localization (i18n support)
   ✓ Environment config (.env)
   ✓ API client (Dio + interceptors)
   ✓ Test scaffolding

📋 Configuration Summary:
   App name: my_awesome_app
   State management: provider
   Theme: ✅
   Localization: ✅
   Environment: ✅
   API client: ✅
   Tests: ✅

✔ 🚀 Ready to generate your app? · yes

🚀 Generating project structure...
✅ Generated 43 files successfully!

Features:

• 🎨 Beautiful UI with emojis and colors
• ⌨️ Arrow key navigation for selections
• ☑️ Multi-select checkboxes for features (spacebar to toggle)
• ✅ Smart validation (prevents reserved words, invalid names)
• 📋 Configuration preview before generation

⚡ Quick Mode (For Experienced Users) #

Skip the wizard by providing the app name:

flutter_blueprint init my_app

Add flags for full control:

# Provider template (classic ChangeNotifier pattern)
flutter_blueprint init my_app \
  --state provider \
  --theme \
  --env \
  --api \
  --tests

# Riverpod template (compile-time safe with StateNotifier)
flutter_blueprint init my_app \
  --state riverpod \
  --theme \
  --env \
  --api \
  --tests \
  --no-localization

# With CI/CD configuration
flutter_blueprint init my_app --ci github
flutter_blueprint init my_app --state riverpod --ci gitlab
flutter_blueprint init my_app --state bloc --ci azure

# Multi-platform support (NEW!)
flutter_blueprint init my_app --platforms mobile,web
flutter_blueprint init my_app --platforms all --state bloc
flutter_blueprint init my_desktop_app --platforms desktop --state riverpod

Hybrid Mode (Mix Both) #

flutter_blueprint init my_app --state riverpod
# Prompts for remaining options

� Multi-Platform Support (NEW in v0.4.0!) #

Build apps that run on mobile, web, AND desktop from a single codebase! flutter_blueprint now generates universal multi-platform projects with responsive layouts, adaptive navigation, and platform-specific optimizations.

Quick Start #

# Mobile + Web
flutter_blueprint init my_app --platforms mobile,web --state bloc

# All platforms (universal app)
flutter_blueprint init my_app --platforms all --state riverpod

# Desktop only
flutter_blueprint init my_desktop_app --platforms desktop --state provider

Platform Options #

Interactive Multi-Select #

In wizard mode, select multiple platforms with checkboxes:

💻 Choose target platforms (space to select, enter to confirm):
[x] Mobile (iOS & Android)
[x] Web
[x] Desktop (Windows, macOS, Linux)

What Gets Generated for Multi-Platform #

Universal Entry Points:

lib/
├── main.dart              # Universal router (detects platform)
├── main_mobile.dart       # Mobile-specific initialization
├── main_web.dart          # Web-specific initialization (URL strategy)
└── main_desktop.dart      # Desktop-specific initialization (window manager)

Responsive & Adaptive Components:

lib/core/responsive/
├── breakpoints.dart           # Mobile/Tablet/Desktop breakpoints
├── responsive_layout.dart     # Responsive widget (adapts to screen size)
├── adaptive_scaffold.dart     # Adaptive navigation (bottom nav → rail → drawer)
└── responsive_spacing.dart    # Responsive padding & spacing helpers

lib/core/utils/
└── platform_info.dart         # Platform detection utilities

Platform-Specific Files:

• Web: web/index.html, web/manifest.json (PWA-ready)
• Desktop: Window configuration, title bar customization

Smart Dependency Management #

Dependencies are automatically added based on selected platforms:

# Common (all platforms)
dependencies:
  # Responsive & sizing (recommended)
  flutter_screenutil: ^5.7.1

  # Web-specific
  url_strategy: ^0.3.0

  # Desktop-specific
  window_manager: ^0.4.3
  path_provider: ^2.1.5

Responsive Features #

Breakpoints:

// The generated responsive utilities use flutter_screenutil and LayoutBuilder.
// Example breakpoint helpers are provided in `core/config/responsive_config.dart`.
if (Breakpoints.isMobile(context)) {
  // Show mobile layout
} else if (Breakpoints.isTablet(context)) {
  // Show tablet layout
} else {
  // Show desktop layout
}

Responsive Layouts:

ResponsiveLayout(
  mobile: MobileView(),    // < 768px
  tablet: TabletView(),    // 768px - 1280px
  desktop: DesktopView(),  // >= 1280px
)

Adaptive Navigation:

• Mobile: Bottom navigation bar
• Tablet: Navigation rail
• Desktop: Side drawer/rail

Platform Detection #

if (PlatformInfo.isWeb) {
  // Web-specific code
} else if (PlatformInfo.isDesktop) {
  // Desktop-specific code
} else if (PlatformInfo.isMobile) {
  // Mobile-specific code
}

Running Multi-Platform Projects #

# Mobile
flutter run -d <device-id>

# Web
flutter run -d chrome

# Desktop
flutter run -d windows  # or macos, linux

Building for Production #

# Mobile
flutter build apk        # Android
flutter build ios        # iOS

# Web
flutter build web

# Desktop
flutter build windows    # Windows
flutter build macos      # macOS
flutter build linux      # Linux

When to Use Multi-Platform #

✅ Use multi-platform when:

• Building web + mobile versions of the same app
• Need desktop companion app for your mobile app
• Want to maximize code reuse across platforms
• Building internal tools that need to run everywhere

❌ Use single-platform when:

• Platform-specific features are critical (AR, NFC, etc.)
• Performance is absolutely critical
• Simple mobile-only app
• Heavy platform-specific UI requirements

🚀 CI/CD Integration #

Generate production-ready CI/CD configurations with a single flag. Your project will be ready for automated testing and deployment from day one!

Quick Start #

# GitHub Actions
flutter_blueprint init my_app --ci github

# GitLab CI
flutter_blueprint init my_app --ci gitlab

# Azure Pipelines
flutter_blueprint init my_app --ci azure

What Gets Generated #

Pipeline Features #

All generated CI/CD configurations include:

• ✅ Code Quality: flutter analyze + dart format checks
• 🧪 Automated Testing: Unit tests with coverage reporting
• 📱 Android Build: APK generation with artifact upload
• 🍎 iOS Build: IPA generation (with codesigning instructions)
• 📊 Coverage Reports: Codecov integration (GitHub) / built-in reports
• 🔄 Auto-retry: Failed requests handled automatically
• 📦 Artifact Storage: Build outputs saved for 7 days

Example: GitHub Actions Workflow #

name: CI/CD Pipeline

on:
  push:
    branches: [main, develop]
  pull_request:
    branches: [main, develop]

jobs:
  analyze:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: subosito/flutter-action@v2
      - run: flutter analyze
      - run: dart format --set-exit-if-changed .

  test:
    needs: analyze
    runs-on: ubuntu-latest
    steps:
      - run: flutter test --coverage
      - uses: codecov/codecov-action@v4

  build-android:
    needs: test
    runs-on: ubuntu-latest
    steps:
      - run: flutter build apk --release
      - uses: actions/upload-artifact@v4

Deployment Ready #

Generated workflows include commented templates for:

• 🔥 Firebase App Distribution - Deploy to testers instantly
• 🍎 TestFlight - iOS beta deployment
• ✍️ Code Signing - Instructions for production builds

Setup Instructions #

After generating your project with CI/CD:

For GitHub Actions:

1. Push your code to GitHub
2. Workflow runs automatically on push/PR
3. (Optional) Add CODECOV_TOKEN secret for coverage reports

For GitLab CI:

1. Push your code to GitLab
2. Pipeline runs automatically on push/MR
3. For iOS builds: Configure macOS runner in .gitlab-ci.yml

For Azure Pipelines:

1. Push your code to Azure Repos
2. Install Flutter extension for Azure Pipelines
3. Pipeline runs automatically on push/PR

🤝 Collaboration & Team Features #

Shared Blueprint Configurations #

Share standards across your entire team! Flutter Blueprint includes a powerful configuration sharing system that lets you create, share, and enforce project standards organization-wide.

Why Use Shared Configurations? #

• Instant consistency - All team members use the same setup
• Faster onboarding - New developers start with proven templates
• Enforce standards - Architecture decisions baked into project creation
• Share best practices - Distribute knowledge through configuration
• Reduce setup time - From hours to seconds

Share Command #

Manage shared configurations with the share command:

# List all available shared configurations
flutter_blueprint share list

# Import a configuration from file
flutter_blueprint share import ./company_standard.yaml

# Import with custom name
flutter_blueprint share import ./config.yaml --name my_config

# Export a configuration
flutter_blueprint share export company_standard ./exported.yaml

# Delete a configuration
flutter_blueprint share delete old_config

# Validate a configuration file
flutter_blueprint share validate ./config.yaml

# Use a shared configuration to create project
flutter_blueprint init my_app --from-config company_standard

Configuration Structure #

Shared configurations can define:

name: company_standard
description: Company-wide Flutter project standards
version: 1.0.0
author: Engineering Team

# State management preference
state_management: bloc # bloc, provider, riverpod

# Supported platforms
platforms:
  - android
  - ios
  - web
  - windows

# CI/CD provider
cicd_provider: github # github, gitlab, azure

# Code style preferences
code_style:
  line_length: 120
  prefer_single_quotes: true
  use_trailing_commas: true

# Architecture rules
architecture:
  enforce_clean_architecture: true
  feature_structure: domain_driven
  use_dependency_injection: true

# Required packages
required_packages:
  - dio
  - get_it
  - injectable
  - flutter_bloc
  - equatable

# Testing requirements
testing:
  require_unit_tests: true
  require_widget_tests: true
  min_coverage: 80

# Custom metadata
metadata:
  team: mobile_engineering
  updated: 2025-11-01

Example Configurations Included #

Flutter Blueprint comes with 3 production-ready configurations:

1. Company Standard (company_standard)

Enterprise-grade setup with Bloc, full platform support, and comprehensive testing:

flutter_blueprint init my_app --from-config company_standard

Features:

• Bloc state management
• All platforms (Android, iOS, Web, Windows, macOS, Linux)
• GitHub Actions CI/CD
• 120 char line length
• Clean Architecture enforced
• Required packages: dio, get_it, injectable, flutter_bloc

2. Startup Template (startup_template)

Lightweight MVP configuration for rapid prototyping:

flutter_blueprint init my_mvp --from-config startup_template

Features:

• Provider state management (simpler learning curve)
• Mobile-first (Android, iOS, Web)
• GitHub Actions CI/CD
• Minimal package dependencies
• Fast iteration focus

3. Enterprise Template (enterprise_template)

Full-featured configuration for large-scale applications:

flutter_blueprint init my_enterprise_app --from-config enterprise_template

Features:

• Riverpod state management
• All platforms
• Azure Pipelines (enterprise CI/CD)
• Strict code style (80 char lines)
• Comprehensive testing requirements (80% coverage)
• Full dependency injection with get_it + injectable

Creating Custom Configurations #

1. Export an existing configuration as a starting point:

flutter_blueprint share export company_standard ./my_template.yaml

2. Edit the YAML file to match your needs:

name: my_custom_config
description: My team's Flutter standards
version: 1.0.0

state_management: riverpod
platforms:
  - android
  - ios
  - web

code_style:
  line_length: 100
  prefer_single_quotes: true

required_packages:
  - riverpod
  - freezed
  - dio

3. Import your custom configuration:

flutter_blueprint share import ./my_template.yaml

4. Use it to create projects:

flutter_blueprint init my_app --from-config my_custom_config

Team Workflow Example #

Setup (One-time):

# Engineering lead creates and shares configuration
flutter_blueprint share import ./company_standard.yaml

# Commit the configuration file to your team repo
git add shared_configs/company_standard.yaml
git commit -m "Add company Flutter standard"
git push

Daily Use (All developers):

# Pull latest configurations
git pull

# Import any new/updated configurations
flutter_blueprint share import ./shared_configs/company_standard.yaml

# Create new project using shared standard
flutter_blueprint init my_new_feature --from-config company_standard

# All team members get identical setup! ✨

Validation #

All configurations are validated before use:

# Validate before importing
flutter_blueprint share validate ./config.yaml

Checks:

• Required fields present (name, version, state_management)
• Valid state management choice
• Valid platform selections
• Valid CI/CD provider
• Proper YAML structure
• Package names are valid

Benefits for Teams #

Documentation #

For complete documentation on collaboration features, see:

• COLLABORATION_FEATURES.md - Comprehensive collaboration guide
• PERFORMANCE_OPTIMIZATION.md - Performance monitoring and optimization

🎯 State Management Templates #

flutter_blueprint supports multiple state management patterns — choose the one that fits your team and project best!

📊 Comparison Table #

🟢 Provider Template #

When to use: You want simplicity, familiarity, and quick onboarding for new Flutter developers.

Example State Management:

// home_provider.dart
class HomeProvider extends ChangeNotifier {
  bool _isLoading = false;
  int _counter = 0;

  void incrementCounter() {
    _counter++;
    notifyListeners(); // Manual notification
  }
}

// home_content.dart
Consumer<HomeProvider>(
  builder: (context, provider, child) {
    return Text('Counter: ${provider.counter}');
  },
)

🟦 Riverpod Template (NEW!) #

When to use: You want compile-time safety, better testability, and you're building a large-scale app.

Example State Management:

// home_provider.dart
class HomeState {
  final bool isLoading;
  final int counter;

  HomeState({required this.isLoading, required this.counter});

  HomeState copyWith({bool? isLoading, int? counter}) {
    return HomeState(
      isLoading: isLoading ?? this.isLoading,
      counter: counter ?? this.counter,
    );
  }
}

class HomeNotifier extends StateNotifier<HomeState> {
  HomeNotifier() : super(HomeState(isLoading: false, counter: 0));

  void incrementCounter() {
    state = state.copyWith(counter: state.counter + 1); // Immutable update
  }
}

final homeProvider = StateNotifierProvider<HomeNotifier, HomeState>((ref) {
  return HomeNotifier();
});

// home_content.dart
class HomeContent extends ConsumerWidget {
  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final homeState = ref.watch(homeProvider); // Auto-rebuild on changes
    return Column(
      children: [
        Text('Counter: ${homeState.counter}'),
        ElevatedButton(
          onPressed: () => ref.read(homeProvider.notifier).incrementCounter(),
          child: Text('Increment'),
        ),
      ],
    );
  }
}

Riverpod Benefits:

• ✅ No BuildContext needed - access providers anywhere
• ✅ Compile-time errors - typos caught immediately
• ✅ Immutable state - easier debugging with state history
• ✅ Auto-disposal - no memory leaks
• ✅ Better testing - use ProviderContainer for isolated tests
• ✅ Family & AutoDispose modifiers for advanced use cases

🟣 Bloc Template (Coming Soon!) #

When to use: You need event-driven architecture, complex business logic, or team is familiar with BLoC pattern.

Stay tuned for Bloc support!

🧩 Generated Project Structure (43+ Files!) #

my_app/
├── lib/
│   ├── main.dart                              # App entry point
│   ├── app/
│   │   └── app.dart                           # Root app widget with providers
│   ├── core/
│   │   ├── api/                               # 🌐 Network layer
│   │   │   ├── api_client.dart                #   Dio client with GET/POST/PUT/DELETE
│   │   │   ├── api_response.dart              #   Generic response wrapper
│   │   │   └── interceptors/
│   │   │       ├── auth_interceptor.dart      #   Auto-add auth tokens
│   │   │       ├── retry_interceptor.dart     #   Auto-retry failed requests
│   │   │       └── logger_interceptor.dart    #   Log all API calls
│   │   ├── config/
│   │   │   ├── app_config.dart                # 🎛️ App configuration
│   │   │   └── env_loader.dart                #   Dev/Stage/Prod environments
│   │   ├── constants/
│   │   │   ├── app_constants.dart             # 📋 Timeouts, storage keys, pagination
│   │   │   └── api_endpoints.dart             #   Centralized API routes
│   │   ├── errors/
│   │   │   ├── exceptions.dart                # 🚨 9 custom exception types
│   │   │   └── failures.dart                  #   Clean architecture failures
│   │   ├── network/
│   │   │   └── network_info.dart              # 📡 Connectivity monitoring
│   │   ├── routing/
│   │   │   ├── app_router.dart                # 🧭 Route management
│   │   │   ├── route_guard.dart               #   Auth guards
│   │   │   └── route_names.dart               #   Centralized route constants
│   │   ├── storage/
│   │   │   ├── local_storage.dart             # 💾 SharedPreferences wrapper
│   │   │   └── secure_storage.dart            #   Secure token storage
│   │   ├── theme/
│   │   │   ├── app_theme.dart                 # 🎨 Light/Dark themes
│   │   │   ├── app_colors.dart                #   Color palette
│   │   │   └── typography.dart                #   Text styles
│   │   ├── utils/
│   │   │   ├── logger.dart                    # 📝 Pro logger (debug/info/warn/error)
│   │   │   ├── validators.dart                #   Form validators (email/phone/etc)
│   │   │   └── extensions.dart                #   String/DateTime/Context extensions
│   │   └── widgets/                           # 🧩 Reusable UI components
│   │       ├── loading_indicator.dart         #   Loading spinner
│   │       ├── error_view.dart                #   Error display with retry
│   │       ├── empty_state.dart               #   Empty list placeholder
│   │       ├── custom_button.dart             #   Button with loading state
│   │       └── custom_text_field.dart         #   Styled text input
│   └── features/
│       └── home/                              # 🏠 Sample feature (clean architecture)
│           └── presentation/
│               ├── pages/
│               │   └── home_page.dart         #   Home screen
│               ├── providers/
│               │   └── home_provider.dart     #   State management
│               └── widgets/
│                   └── home_content.dart      #   Home UI components
├── assets/
│   └── l10n/
│       ├── en.arb                             # 🌍 English translations
│       └── hi.arb                             #   Hindi translations
├── test/
│   ├── widget_test.dart                       # 🧪 Sample widget test
│   ├── core/
│   │   └── utils/
│   │       └── validators_test.dart           #   Validator unit tests
│   └── helpers/
│       └── test_helpers.dart                  #   Test utilities
├── .env.example                               # 🔐 Environment variables template
├── blueprint.yaml                             # 📘 Project metadata
└── pubspec.yaml                               # 📦 Dependencies

File Count by Feature Set:

• Minimal (no optional features): 19 files
• Full Stack (all features enabled): 43 files 🚀

🧠 Architecture Principles #

Clean Separation of Concerns #

• core/: Shared infrastructure (config, theme, routing, API)
• features/: Business logic organized by feature
• app/: Root app configuration and providers

Dependency Injection Ready #

Uses Provider for service location:

Provider<AppConfig>(create: (_) => AppConfig.load()),
Provider<ApiClient>(create: (context) => ApiClient(context.read<AppConfig>())),

Type-Safe Configuration #

class AppConfig {
  final String appTitle;
  final String environment;
  final String apiBaseUrl;
  // ...
}

🛠️ CLI Commands #

init - Create New Project #

flutter_blueprint init <app_name> [options]

Options:

add feature - Incremental feature generation (killer feature) #

Add a new feature to an existing project without touching the rest of your app. The command scaffolds clean-architecture folders (data/domain/presentation), generates state-management boilerplate that matches the project's blueprint.yaml (Provider, Riverpod or BLoC), and injects a new route into app_router.dart.

Usage:

# Full feature with all layers
flutter_blueprint add feature <feature_name>

# Only presentation layer
flutter_blueprint add feature settings --presentation --no-data --no-domain

# Add feature with remote API integration
flutter_blueprint add feature products --api

Flags:

Behavior & notes:

• The command must be run from the root of a previously generated flutter_blueprint project (it reads blueprint.yaml).
• It detects the project's state-management setting from blueprint.yaml and emits matching files for Provider, Riverpod, or Bloc.
• If app_router.dart exists, the generator will add the page import, a route constant to RouteNames, and a case in the router switch to return the new page.
• The generator is idempotent for route insertion: it will not duplicate imports or constants if they already exist.
• For Riverpod/Bloc the generated state files follow the project's Dart version (uses sealed classes / StateNotifier / Bloc patterns as appropriate).

Examples:

# Generate a full "auth" feature using the project's state-management
flutter_blueprint add feature auth

# Generate only presentation for "settings"
flutter_blueprint add feature settings --presentation --no-data --no-domain

# Generate products feature and include remote API data source
flutter_blueprint add feature products --api

📋 blueprint.yaml #

Every generated project includes a blueprint.yaml manifest:

version: 1
app_name: my_app
platforms:
  - mobile
  - web
state_management: provider
ci_provider: github
features:
  api: true
  env: true
  localization: false
  tests: true
  theme: true

Future Use: This enables regeneration, upgrades, and feature addition.

🎯 Target Audience #

• Junior developers: who don't yet know how to structure a real project
• Indie devs: who want to spin up production-ready apps quickly
• Small teams: who want standardization without heavy frameworks

🚧 Roadmap #

Phase 1: MVP ✅ #

• ✅ CLI tool setup
• ✅ Basic project generator
• ✅ Provider template
• ✅ Theme + routing boilerplate

Phase 2: Multi-Template Support ✅ #

• ✅ Riverpod template
• ✅ Bloc template
• ✅ Localization integration
• ✅ API client scaffolding

Phase 3: Platform Expansion ✅ (v0.4.0) #

• ✅ Multi-platform support (mobile, web, desktop)
• ✅ Responsive layout system
• ✅ Adaptive navigation
• ✅ Universal project generation
• ✅ Platform-specific optimizations

Phase 4: Feature Generation ✅ (v0.3.0) #

• ✅ flutter_blueprint add feature <name>
• ✅ Clean architecture layers
• ✅ Auto-router integration
• ✅ State management detection

Phase 5: DevOps Integration ✅ (v0.5.0) #

• ✅ GitHub Actions CI/CD scaffold
• ✅ GitLab CI pipelines
• ✅ Azure Pipelines support
• ✅ Automated testing & builds
• ✅ Firebase deployment templates

Phase 6: Future Enhancements 🚀 #

• ❌ Interactive upgrades via blueprint.yaml
• ❌ Plugin ecosystem (auth, firebase, analytics)
• ❌ VSCode/IntelliJ extensions
• ❌ Blueprint dashboard (web-based config UI)
• ❌ Project migration tools
• ❌ Custom template support

🤝 Contributing #

Contributions are welcome! Please read our Contributing Guide first.

1. Fork the repo
2. Create your feature branch (git checkout -b feature/amazing-feature)
3. Commit your changes (git commit -m 'Add amazing feature')
4. Push to the branch (git push origin feature/amazing-feature)
5. Open a Pull Request

📄 License #

This project is licensed under the MIT License - see the LICENSE file for details.

💬 Support #

• 📧 Email: [email protected]
• 🐛 Issues: GitHub Issues
• 💬 Discussions: GitHub Discussions

🤖 Automated Publishing & Versioning #

This package uses fully automated CI/CD with GitHub Actions. No manual version bumps or publishing needed!

How It Works #

1. Make changes to the code
2. Commit with conventional messages:
   • feat: → auto minor version bump (0.5.1 → 0.6.0)
   • fix: or other → auto patch bump (0.5.1 → 0.5.2)
   • feat!: or BREAKING CHANGE: → auto major bump (0.5.1 → 1.0.0)
3. Push to main → automatic version bump, tag creation, and publish to pub.dev!

Example Workflow #

# Make changes
git add lib/src/generator/new_feature.dart

# Commit with conventional message
git commit -m "feat: add amazing new feature"

# Push to main
git push origin main

Result: Version automatically bumps to 0.6.0, tag v0.6.0 is created, and package is published to pub.dev! 🎉

Skip Auto-Versioning #

Add [skip-version] to your commit message when you don't want a release:

git commit -m "docs: update README [skip-version]"

Manual Version Control #

If you prefer manual control, use the helper scripts in scripts/:

PowerShell (Windows):

.\scripts\publish.ps1 -Version 0.5.2

Bash (macOS / Linux):

./scripts/publish.sh 0.5.2

Setup Instructions #

For automated publishing to work, you need to:

1. Enable pub.dev OIDC (one-time setup):

   • Go to pub.dev → Your package → Admin → Automated publishing
   • Enable GitHub Actions with:
     • Repository: chirag640/flutter_blueprint-Package
     • Tag pattern: v{{version}}
     • ✅ Enable push events
     • ✅ Enable workflow_dispatch

2. Configure GitHub permissions:

   • Go to Settings → Actions → General
   • Set workflow permissions to "Read and write"
   • ✅ Allow GitHub Actions to create and approve pull requests

3. Done! Now every push to main will trigger auto-versioning and publishing.

📖 Full documentation: See docs/AUTOMATED_PUBLISHING.md for complete setup guide and troubleshooting.

🌟 Show Your Support #

If this project helped you, please ⭐ the repository and share it with others!

Made with ❤️ for the Flutter community