# Clone the repository
git clone https://github.com/Sen2pi/Bloquinho.git
cd Bloquinho

# Install dependencies
flutter pub get

# Run the application
flutter run

lib/
├── core/                     # Core services and models
│   ├── services/            # Storage, auth, cloud services
│   │   ├── storage/         # Local storage abstraction
│   │   ├── auth/           # Authentication providers
│   │   ├── cloud/          # Cloud storage integration
│   │   └── encryption/     # End-to-end encryption
│   ├── models/             # Data models with JSON serialization
│   │   ├── page_model.dart
│   │   ├── workspace_model.dart
│   │   └── user_model.dart
│   ├── l10n/               # Internationalization
│   │   ├── app_strings.dart
│   │   └── templates/      # Language-specific templates
│   └── constants/          # App constants and configuration
├── features/               # Feature modules (vertical slices)
│   ├── bloquinho/         # Main editor and pages
│   │   ├── presentation/  # UI components
│   │   ├── domain/        # Business logic
│   │   └── data/          # Data layer
│   ├── database/          # Database management
│   ├── workspace/         # Workspace management
│   ├── auth/              # Authentication
│   └── settings/          # Application settings
├── shared/                # Shared components and providers
│   ├── widgets/           # Reusable UI components
│   ├── providers/         # Riverpod providers
│   └── utils/             # Utility functions
└── main.dart             # Application entry point

// core/l10n/templates/base_template.dart
abstract class BaseTemplate {
  const BaseTemplate();

  String get rootPageTemplate;
  String get newPageTemplate;
  String get meetingTemplate;
  String get projectTemplate;
  String get taskListTemplate;
  String get databaseTemplate;

  // Contextual templates based on user behavior
  String getContextualTemplate(TemplateContext context);
}

// core/l10n/templates/page_templates_pt.dart
class PageTemplatesPt extends BaseTemplate {
  static const String rootPageTemplate = '''# 📊 Espaço de Trabalho Bloquinho

## 🎯 Visão Geral do Projeto

Bem-vindo ao seu espaço de trabalho personalizado! Este documento demonstra todas as funcionalidades avançadas do Bloquinho.

### 🚀 Funcionalidades Principais

1. **Editor Markdown Avançado**
   - Suporte completo para LaTeX: \$E = mc^2\$
   - Diagramas Mermaid integrados
   - Syntax highlighting para 20+ linguagens

2. **Sistema de Base de Dados**
   - Tabelas relacionais customizáveis
   - Visualizações dinâmicas
   - Exportação para CSV/JSON

3. **Gestão de Projectos**
   - Quadros Kanban
   - Gráficos de Gantt
   - Rastreamento de tempo

### 📋 Lista de Tarefas Inteligente

- [x] <span style="color:green">**Configuração inicial**</span> ✅
- [x] <span style="color:green">**Importação de dados**</span> ✅
- [ ] <span style="color:orange">**Configuração de equipa**</span> 🔄
- [ ] <span style="color:red">**Primeiro milestone**</span> ⏳

### 🔢 Fórmulas Matemáticas

Fórmula quadrática: \$x = \\frac{-b \\pm \\sqrt{b^2 - 4ac}}{2a}\$

Integral definida:
\$\\int_a^b f(x) \\, dx = F(b) - F(a)\$

### 💻 Exemplo de Código

### 📊 Tabela de Métricas

| Métrica | Valor Actual | Meta | Estado |
|---------|-------------|------|--------|
| Produtividade | 85% | 90% | <span style="color:orange">⚠ Melhorar</span> |
| Qualidade | 92% | 95% | <span style="color:green">✅ Bom</span> |
| Satisfação | 88% | 85% | <span style="color:green">✅ Excelente</span> |

### 🗂 Estrutura de Páginas Recomendada

### 🎨 Elementos Visuais

<div style="background-color:#e8f5e8; border:1px solid #4caf50; border-radius:8px; padding:15px; margin:15px 0;">
<strong style="color:#2e7d32;">💡 Dica Profissional</strong><br>
Use esta página como ponto de partida para organizar todo o seu trabalho. Personalize as secções conforme as suas necessidades.
</div>

---

**Criado com ❤ usando Bloquinho** | *Última actualização: {{date}}*
''';

  static const String newPageTemplate = '''# Nova Página

## 📝 Introdução

Bem-vindo à sua nova página! Comece a escrever o seu conteúdo aqui.

### 🎯 Objectivos

- [ ] Definir objectivos claros
- [ ] Estruturar o conteúdo
- [ ] Adicionar recursos necessários

### 💡 Notas

> **Lembrete**: Use markdown para formatar o seu texto e criar conteúdo rico.

### 🔗 Ligações Úteis

- [Documentação Bloquinho](https://bloquinho.kpsolucoes.pt)
- [Guia de Markdown](https://www.markdownguide.org)
''';

  static const String meetingTemplate = '''# 📅 Reunião - {{title}}

## 📋 Detalhes da Reunião

**Data**: {{date}}
**Hora**: {{time}}
**Duração**: {{duration}}
**Participantes**: {{participants}}

## 🎯 Agenda

1. **Abertura** (5 min)
2. **Revisão de acções anteriores** (10 min)
3. **Tópicos principais** (30 min)
4. **Próximos passos** (10 min)
5. **Encerramento** (5 min)

## 📝 Notas da Reunião

### Tópicos Discutidos

#### 1. [Tópico 1]
- Ponto importante 1
- Ponto importante 2
- Decisão tomada

#### 2. [Tópico 2]
- Discussão relevante
- Conclusões

## ✅ Acções Decididas

| Acção | Responsável | Prazo | Estado |
|-------|-------------|-------|--------|
| Acção 1 | @pessoa | dd/mm/aaaa | [ ] |
| Acção 2 | @pessoa | dd/mm/aaaa | [ ] |

## 🔄 Próxima Reunião

**Data**: {{next_date}}
**Tópicos**: A definir
''';

  @override
  String getContextualTemplate(TemplateContext context) {
    switch (context.type) {
      case TemplateType.meeting:
        return meetingTemplate
            .replaceAll('{{title}}', context.title)
            .replaceAll('{{date}}', context.date)
            .replaceAll('{{time}}', context.time ?? 'A definir')
            .replaceAll('{{duration}}', context.duration ?? '1 hora')
            .replaceAll('{{participants}}', context.participants?.join(', ') ?? 'A definir');
      case TemplateType.project:
        return projectTemplate;
      case TemplateType.taskList:
        return taskListTemplate;
      default:
        return newPageTemplate;
    }
  }
}

// core/services/page_template_service.dart
class PageTemplateService {
  static final Map<AppLanguage, BaseTemplate> _templates = {
    AppLanguage.portuguese: PageTemplatesPt(),
    AppLanguage.english: PageTemplatesEn(),
    AppLanguage.french: PageTemplatesFr(),
    AppLanguage.spanish: PageTemplatesEs(),
  };

  /// Advanced template selection with AI-like intelligence
  static String getTemplate(AppLanguage language, PageTemplateType type, {
    TemplateContext? context,
    UserPreferences? preferences,
    List<String>? recentPages,
  }) {
    final template = _templates[language]!;

    // Analyze user behavior patterns
    final suggestedType = _analyzeUserBehavior(type, recentPages, preferences);

    switch (suggestedType) {
      case PageTemplateType.root:
        return template.rootPageTemplate;
      case PageTemplateType.meeting:
        return template.getContextualTemplate(context ?? TemplateContext.empty());
      case PageTemplateType.project:
        return template.projectTemplate;
      case PageTemplateType.database:
        return template.databaseTemplate;
      default:
        return template.newPageTemplate;
    }
  }

  /// Analyze user behavior to suggest appropriate templates
  static PageTemplateType _analyzeUserBehavior(
    PageTemplateType requestedType,
    List<String>? recentPages,
    UserPreferences? preferences,
  ) {
    // Implement ML-like logic for template suggestion
    if (recentPages != null && recentPages.isNotEmpty) {
      // If user frequently creates meeting pages, suggest meeting template
      final meetingKeywords = ['meeting', 'reunião', 'réunion', 'reunión'];
      final recentMeetings = recentPages.where((page) =>
          meetingKeywords.any((keyword) => page.toLowerCase().contains(keyword)));

      if (recentMeetings.length > recentPages.length * 0.3) {
        return PageTemplateType.meeting;
      }
    }

    return requestedType;
  }

  /// Detect root page candidates with advanced heuristics
  static bool isRootPageCandidate(String title, {
    String? parentId,
    int? hierarchyLevel,
    AppLanguage? language,
  }) {
    final normalizedTitle = title.toLowerCase().trim();

    // Language-specific root page detection
    final rootPageTitles = _getRootPageTitles(language ?? AppLanguage.english);

    // Check direct matches
    if (rootPageTitles.contains(normalizedTitle)) return true;

    // Check if it's a top-level page without parent
    if (parentId == null && (hierarchyLevel ?? 0) == 0) return true;

    // Check fuzzy matches for common root page patterns
    final fuzzyMatches = [
      RegExp(r'^(main|principal|início|home|accueil|inicio).*$'),
      RegExp(r'^.*(dashboard|workspace|área.*trabalho|espace.*travail).*$'),
      RegExp(r'^(index|índice|sommaire|índice).*$'),
    ];

    return fuzzyMatches.any((pattern) => pattern.hasMatch(normalizedTitle));
  }

  /// Get localized root page titles
  static Set<String> _getRootPageTitles(AppLanguage language) {
    switch (language) {
      case AppLanguage.portuguese:
        return {
          'main', 'principal', 'início', 'home', 'dashboard', 'workspace',
          'área de trabalho', 'espaço de trabalho', 'índice', 'raiz'
        };
      case AppLanguage.english:
        return {
          'main', 'home', 'dashboard', 'workspace', 'index', 'root',
          'overview', 'main page', 'home page'
        };
      case AppLanguage.french:
        return {
          'main', 'accueil', 'tableau de bord', 'espace de travail',
          'index', 'racine', 'aperçu', 'page principale'
        };
      case AppLanguage.spanish:
        return {
          'main', 'principal', 'inicio', 'tablero', 'espacio de trabajo',
          'índice', 'raíz', 'página principal', 'resumen'
        };
    }
  }
}

// core/models/template_context.dart
class TemplateContext {
  final TemplateType type;
  final String title;
  final String date;
  final String? time;
  final String? duration;
  final List<String>? participants;
  final Map<String, dynamic>? customData;
  final UserPreferences? userPreferences;

  const TemplateContext({
    required this.type,
    required this.title,
    required this.date,
    this.time,
    this.duration,
    this.participants,
    this.customData,
    this.userPreferences,
  });

  factory TemplateContext.empty() => TemplateContext(
        type: TemplateType.basic,
        title: '',
        date: DateTime.now().toIso8601String(),
      );

  factory TemplateContext.meeting({
    required String title,
    required DateTime date,
    String? time,
    String? duration,
    List<String>? participants,
  }) => TemplateContext(
        type: TemplateType.meeting,
        title: title,
        date: _formatDate(date),
        time: time,
        duration: duration,
        participants: participants,
      );

  static String _formatDate(DateTime date) {
    return '${date.day}/${date.month}/${date.year}';
  }
}

enum TemplateType {
  basic,
  meeting,
  project,
  taskList,
  database,
  research,
  documentation,
}

// features/bloquinho/presentation/providers/pages_provider.dart
class PagesNotifier extends StateNotifier<AsyncValue<List<PageModel>>> {
  final PagesRepository _repository;
  final PageTemplateService _templateService;
  final UserPreferencesService _preferencesService;

  PagesNotifier(this._repository, this._templateService, this._preferencesService)
      : super(const AsyncValue.loading());

  /// Create new page with intelligent template selection
  Future<PageModel> createPageWithIntelligentTemplate({
    required String title,
    String? icon,
    String? parentId,
    TemplateContext? context,
    AppLanguage? language,
  }) async {
    try {
      // Get user preferences and language
      final preferences = await _preferencesService.getUserPreferences();
      final userLanguage = language ?? preferences.language;

      // Get recent pages for behavior analysis
      final recentPages = await _repository.getRecentPages(limit: 20);

      // Determine template type
      final templateType = _determineTemplateType(title, parentId, context);

      // Get appropriate template
      final template = _templateService.getTemplate(
        userLanguage,
        templateType,
        context: context,
        preferences: preferences,
        recentPages: recentPages.map((p) => p.title).toList(),
      );

      // Create page with template
      final page = await createPage(
        title: title,
        icon: icon,
        parentId: parentId,
        content: template,
        language: userLanguage,
      );

      // Track user behavior for future suggestions
      await _trackUserBehavior(page, templateType);

      return page;
    } catch (e) {
      throw Exception('Failed to create page with template: $e');
    }
  }

  /// Determine template type based on various factors
  PageTemplateType _determineTemplateType(
    String title,
    String? parentId,
    TemplateContext? context,
  ) {
    if (context != null) {
      return _contextToTemplateType(context.type);
    }

    if (PageTemplateService.isRootPageCandidate(title, parentId: parentId)) {
      return PageTemplateType.root;
    }

    // Analyze title for template hints
    final titleLower = title.toLowerCase();
    if (titleLower.contains('meeting') || titleLower.contains('reunião')) {
      return PageTemplateType.meeting;
    }
    if (titleLower.contains('project') || titleLower.contains('projeto')) {
      return PageTemplateType.project;
    }
    if (titleLower.contains('task') || titleLower.contains('tarefa')) {
      return PageTemplateType.taskList;
    }

    return PageTemplateType.basic;
  }

  /// Track user behavior for ML-like suggestions
  Future<void> _trackUserBehavior(PageModel page, PageTemplateType templateType) async {
    await _repository.trackUserBehavior(UserBehaviorEvent(
      userId: page.userId,
      action: UserAction.createPage,
      templateType: templateType,
      timestamp: DateTime.now(),
      metadata: {
        'title': page.title,
        'hasParent': page.parentId != null,
        'contentLength': page.content.length,
      },
    ));
  }
}

// features/bloquinho/presentation/widgets/template_preview_widget.dart
class TemplatePreviewWidget extends ConsumerWidget {
  final String title;
  final AppLanguage language;
  final TemplateContext? context;

  const TemplatePreviewWidget({
    Key? key,
    required this.title,
    required this.language,
    this.context,
  }) : super(key: key);

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final templateType = PageTemplateService.determineTemplateType(title);
    final template = PageTemplateService.getTemplate(
      language,
      templateType,
      context: context,
    );

    return Card(
      elevation: 4,
      child: Padding(
        padding: const EdgeInsets.all(16),
        child: Column(
          crossAxisAlignment: CrossAxisAlignment.start,
          children: [
            Row(
              children: [
                Icon(
                  _getTemplateIcon(templateType),
                  color: Theme.of(context).primaryColor,
                ),
                const SizedBox(width: 8),
                Text(
                  'Template Preview',
                  style: Theme.of(context).textTheme.titleMedium?.copyWith(
                    fontWeight: FontWeight.bold,
                  ),
                ),
              ],
            ),
            const Divider(),
            Expanded(
              child: SingleChildScrollView(
                child: MarkdownBody(
                  data: template.substring(0, math.min(template.length, 500)) + '...',
                  styleSheet: MarkdownStyleSheet.fromTheme(Theme.of(context)),
                ),
              ),
            ),
          ],
        ),
      ),
    );
  }

  IconData _getTemplateIcon(PageTemplateType type) {
    switch (type) {
      case PageTemplateType.root:
        return Icons.home;
      case PageTemplateType.meeting:
        return Icons.meeting_room;
      case PageTemplateType.project:
        return Icons.folder_special;
      case PageTemplateType.taskList:
        return Icons.checklist;
      default:
        return Icons.description;
    }
  }
}

// core/services/encryption_service.dart
class EncryptionService {
  static const String _keySize = '256';

  /// Encrypt sensitive page content
  static Future<String> encryptContent(String content, String userKey) async {
    final key = Key.fromSecureRandom(32);
    final iv = IV.fromSecureRandom(16);

    final encrypter = Encrypter(AES(key));
    final encrypted = encrypter.encrypt(content, iv: iv);

    return encrypted.base64;
  }

  /// Decrypt page content
  static Future<String> decryptContent(String encryptedContent, String userKey) async {
    // Implementation with proper key derivation
    // ...
  }
}

// core/services/secure_storage_service.dart
class SecureStorageService {
  static const _storage = FlutterSecureStorage();

  /// Store sensitive data with encryption
  static Future<void> storeSecure(String key, String value) async {
    await _storage.write(key: key, value: value);
  }

  /// Retrieve and decrypt sensitive data
  static Future<String?> getSecure(String key) async {
    return await _storage.read(key: key);
  }
}

// features/database/presentation/widgets/table_editor_widget.dart
class TableEditorWidget extends ConsumerWidget {
  final String workspaceId;
  final String? tableId;

  const TableEditorWidget({
    Key? key,
    required this.workspaceId,
    this.tableId,
  }) : super(key: key);

  @override
  Widget build(BuildContext context, WidgetRef ref) {
    final table = ref.watch(tableProvider(tableId));

    return table.when(
      data: (tableData) => Column(
        children: [
          // Table header with drag-and-drop columns
          ReorderableRow(
            children: tableData.columns.map((column) => 
              TableColumnHeader(
                column: column,
                onReorder: (oldIndex, newIndex) => _reorderColumn(oldIndex, newIndex),
                onEdit: (column) => _editColumn(column),
                onDelete: (column) => _deleteColumn(column),
              )
            ).toList(),
          ),
          // Table body with inline editing
          Expanded(
            child: ListView.builder(
              itemCount: tableData.rows.length,
              itemBuilder: (context, index) => TableRowWidget(
                row: tableData.rows[index],
                columns: tableData.columns,
                onCellEdit: (rowId, columnId, value) => _editCell(rowId, columnId, value),
              ),
            ),
          ),
        ],
      ),
      loading: () => const CircularProgressIndicator(),
      error: (error, stack) => ErrorWidget(error),
    );
  }
}

// features/database/models/field_type.dart
enum FieldType {
  text,
  number,
  boolean,
  date,
  datetime,
  select,
  multiSelect,
  file,
  url,
  email,
  phone,
  currency,
  rating,
  progress,
  formula,
  relationship,
  rollup,
  lookup,
}

class FieldDefinition {
  final String id;
  final String name;
  final FieldType type;
  final Map<String, dynamic> options;
  final bool required;
  final dynamic defaultValue;
  final List<ValidationRule> validationRules;

  const FieldDefinition({
    required this.id,
    required this.name,
    required this.type,
    this.options = const {},
    this.required = false,
    this.defaultValue,
    this.validationRules = const [],
  });
}

# Dockerfile
FROM nginx:alpine

# Copy Flutter web build
COPY build/web /usr/share/nginx/html

# Copy custom nginx configuration
COPY nginx.conf /etc/nginx/nginx.conf

# Expose port
EXPOSE 80

# Start nginx
CMD ["nginx", "-g", "daemon off;"]

# docker-compose.yml
version: '3.8'

services:
  bloquinho-web:
    build: .
    ports:
      - "80:80"
    depends_on:
      - bloquinho-api
    environment:
      - API_URL=http://bloquinho-api:3000

  bloquinho-api:
    image: bloquinho/api:latest
    ports:
      - "3000:3000"
    depends_on:
      - postgres
      - redis
    environment:
      - DATABASE_URL=postgresql://user:password@postgres:5432/bloquinho
      - REDIS_URL=redis://redis:6379

  postgres:
    image: postgres:15
    environment:
      - POSTGRES_DB=bloquinho
      - POSTGRES_USER=user
      - POSTGRES_PASSWORD=password
    volumes:
      - postgres_data:/var/lib/postgresql/data

  redis:
    image: redis:7-alpine
    volumes:
      - redis_data:/data

volumes:
  postgres_data:
  redis_data:

# k8s/deployment.yaml
apiVersion: apps/v1
kind: Deployment
metadata:
  name: bloquinho-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: bloquinho
  template:
    metadata:
      labels:
        app: bloquinho
    spec:
      containers:
      - name: bloquinho
        image: bloquinho/app:latest
        ports:
        - containerPort: 80
        env:
        - name: API_URL
          value: "https://api.bloquinho.kpsolucoes.pt"
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"

// core/services/cache_service.dart
class CacheService {
  static final Map<String, dynamic> _cache = {};
  static final Map<String, DateTime> _cacheTimestamps = {};
  static const Duration _cacheExpiration = Duration(minutes: 30);

  /// Cache data with expiration
  static void cache(String key, dynamic data) {
    _cache[key] = data;
    _cacheTimestamps[key] = DateTime.now();
  }

  /// Get cached data if still valid
  static T? getCached<T>(String key) {
    final timestamp = _cacheTimestamps[key];
    if (timestamp == null) return null;

    if (DateTime.now().difference(timestamp) > _cacheExpiration) {
      _cache.remove(key);
      _cacheTimestamps.remove(key);
      return null;
    }

    return _cache[key] as T?;
  }

  /// Invalidate cache
  static void invalidate(String key) {
    _cache.remove(key);
    _cacheTimestamps.remove(key);
  }
}

// shared/providers/optimized_providers.dart
final pagesProvider = StateNotifierProvider.family<PagesNotifier, AsyncValue<List<PageModel>>, WorkspaceKey>(
  (ref, workspaceKey) => PagesNotifier(
    ref.watch(pagesRepositoryProvider),
    ref.watch(pageTemplateServiceProvider),
    ref.watch(userPreferencesServiceProvider),
  ),
);

final pageProvider = FutureProvider.family<PageModel?, String>(
  (ref, pageId) async {
    // Check cache first
    final cached = CacheService.getCached<PageModel>('page_$pageId');
    if (cached != null) return cached;

    // Fetch from repository
    final repository = ref.watch(pagesRepositoryProvider);
    final page = await repository.getPage(pageId);

    // Cache the result
    if (page != null) {
      CacheService.cache('page_$pageId', page);
    }

    return page;
  },
);

// shared/widgets/responsive_layout.dart
class ResponsiveLayout extends StatelessWidget {
  final Widget mobile;
  final Widget tablet;
  final Widget desktop;

  const ResponsiveLayout({
    Key? key,
    required this.mobile,
    required this.tablet,
    required this.desktop,
  }) : super(key: key);

  @override
  Widget build(BuildContext context) {
    return LayoutBuilder(
      builder: (context, constraints) {
        if (constraints.maxWidth < 600) {
          return mobile;
        } else if (constraints.maxWidth < 1200) {
          return tablet;
        } else {
          return desktop;
        }
      },
    );
  }
}

// core/services/platform_service.dart
class PlatformService {
  static bool get isWeb => kIsWeb;
  static bool get isMobile => Platform.isAndroid || Platform.isIOS;
  static bool get isDesktop => Platform.isWindows || Platform.isMacOS || Platform.isLinux;

  /// Get platform-specific file operations
  static FileOperations getFileOperations() {
    if (isWeb) {
      return WebFileOperations();
    } else if (isMobile) {
      return MobileFileOperations();
    } else {
      return DesktopFileOperations();
    }
  }
}

// core/services/realtime_service.dart
class RealtimeService {
  static WebSocketChannel? _channel;
  static final StreamController<RealtimeEvent> _eventController = StreamController.broadcast();

  static Stream<RealtimeEvent> get events => _eventController.stream;

  /// Connect to realtime server
  static Future<void> connect(String workspaceId, String userId) async {
    _channel = WebSocketChannel.connect(
      Uri.parse('wss://realtime.bloquinho.kpsolucoes.pt/workspace/$workspaceId'),
    );

    _channel!.stream.listen((data) {
      final event = RealtimeEvent.fromJson(jsonDecode(data));
      _eventController.add(event);
    });

    // Send authentication
    _channel!.sink.add(jsonEncode({
      'type': 'auth',
      'userId': userId,
      'workspaceId': workspaceId,
    }));
  }

  /// Send page update
  static void sendPageUpdate(String pageId, String content) {
    _channel?.sink.add(jsonEncode({
      'type': 'page_update',
      'pageId': pageId,
      'content': content,
      'timestamp': DateTime.now().toIso8601String(),
    }));
  }
}

// Example: Creating a sprint planning template
final sprintTemplate = '''# 🏃‍♂ Sprint Planning - Sprint {{sprint_number}}

## 📅 Sprint Details
- **Duration**: {{start_date}} - {{end_date}}
- **Sprint Goal**: {{goal}}
- **Team Capacity**: {{capacity}} story points

## 📋 Backlog Items

### 🔥 High Priority
- [ ] {{item_1}} ({{points_1}} pts)
- [ ] {{item_2}} ({{points_2}} pts)

### 🟡 Medium Priority
- [ ] {{item_3}} ({{points_3}} pts)

## 📊 Sprint Metrics

| Metric | Target | Current |
|--------|--------|---------|
| Velocity | {{target_velocity}} | - |
| Burndown | On track | - |
| Quality | 95% | - |

## 🎯 Definition of Done
- [ ] Code reviewed
- [ ] Tests written
- [ ] Documentation updated
- [ ] Deployed to staging
''';

// Example: Research paper template
final researchTemplate = '''# 📚 Research Paper: {{title}}

## 📝 Abstract
{{abstract}}

## 🎯 Research Questions
1. {{question_1}}
2. {{question_2}}
3. {{question_3}}

## 📊 Data Analysis

### Statistical Results

### Visualizations
{{mermaid_charts}}

## 📋 Bibliography
{{bibliography}}
''';

git clone https://github.com/Sen2pi/Bloquinho.git
cd Bloquinho
flutter pub get
flutter run

docker run -p 80:80 bloquinho/app:latest

# Fork the repository
git clone https://github.com/Sen2pi/Bloquinho.git
cd Bloquinho

# Create a feature branch
git checkout -b feature/amazing-feature

# Make your changes and commit
git commit -m "Add amazing feature"

# Push to your fork and create a pull request
git push origin feature/amazing-feature