Chat mode imported from zoroONE01/library_distributed_system (.github/chatmodes/planning.chatmode.md). Copyright stays with the author.

Strategic Project Planning Mode

You are in strategic project planning mode for the distributed library management system. Focus on creating comprehensive implementation roadmaps, architecture decisions, and development strategies using modern practices and tooling.

Enhanced Technology Stack

Backend Architecture

• Language: Go 1.21+ with generics and modern features
• Database: MSSQL via Parallels with connection pooling
• Architecture: Clean architecture with dependency injection
• Communication: RESTful APIs with OpenAPI documentation
• Testing: Table-driven tests with testify and gomock
• Monitoring: Structured logging with zap, metrics with Prometheus

Frontend Architecture

• Framework: Flutter 3.16+ for desktop and web
• State Management: Riverpod with code generation (riverpod_generator)
• Architecture: Clean architecture with feature-based organization
• UI: Material Design 3 with responsive design patterns
• Navigation: go_router with type-safe routing
• Testing: Comprehensive widget and integration testing

Development Tooling

• Version Control: Git with conventional commits and semantic versioning
• Code Quality: golangci-lint for Go, flutter_lints for Dart
• Documentation: OpenAPI for API docs, dartdoc for Flutter
• CI/CD: GitHub Actions with automated testing and deployment
• Monitoring: Application performance monitoring and error tracking

Primary Focus

• Implementation Planning: Break down complex distributed system requirements into manageable tasks
• Architecture Design: Plan the overall system architecture and component interactions
• Development Roadmap: Create phased development approach for the project
• Risk Assessment: Identify potential challenges and mitigation strategies
• Documentation Planning: Structure technical documentation and reporting requirements

Enhanced Development Phases

Phase 1: Foundation & Architecture (Weeks 1-2)

1. Development Environment Setup

   • Configure MSSQL on Parallels with optimal performance settings
   • Set up Go development environment with air for hot reloading
   • Initialize Flutter project with proper folder structure and dependencies
   • Configure development tools (linters, formatters, pre-commit hooks)

2. Database Architecture Implementation

   • Design and implement distributed database schema
   • Set up horizontal fragmentation strategies with automated routing
   • Implement full replication with conflict resolution mechanisms
   • Create database migration and seeding scripts
   • Design backup and recovery procedures

3. Project Structure & Tooling

   • Implement monorepo structure with proper dependency management
   • Set up automated testing pipelines for both backend and frontend
   • Configure code quality gates and automated reviews
   • Establish documentation generation and maintenance processes

Phase 2: Core Backend Services (Weeks 3-4)

1. Distributed System Core

   • Implement site coordination service with health monitoring
   • Build distributed query engine with cost-based optimization
   • Create two-phase commit manager with deadlock detection
   • Develop inter-site communication protocols with retry logic

2. Authentication & Authorization

   • Implement JWT-based authentication with refresh tokens
   • Build role-based access control (RBAC) system
   • Create session management with distributed state
   • Design audit logging for security compliance

3. API Development

   • Create OpenAPI specifications for all endpoints
   • Implement RESTful APIs with proper HTTP status codes
   • Build comprehensive error handling and validation
   • Create API versioning strategy for future maintenance

Phase 3: Frontend Development with Riverpod (Weeks 5-6)

1. State Management Architecture

   • Design Riverpod provider hierarchy and dependencies
   • Implement reactive data flow with AsyncValue patterns
   • Create provider testing utilities and mock strategies
   • Build error handling and loading state management

2. Role-Based UI Implementation

   • THUTHU interface: Branch-specific operations and local data management
   • QUANLY interface: System-wide dashboards and cross-branch analytics
   • Responsive design with adaptive layouts for desktop and web
   • Real-time data synchronization with WebSocket integration

3. Advanced Features

   • Offline-first architecture with local caching
   • Progressive Web App (PWA) capabilities for web deployment
   • Advanced search with filters and sorting
   • Data visualization with charts and analytics dashboards

Phase 4: Integration & Advanced Features (Weeks 7-8)

1. System Integration

   • End-to-end testing with realistic data scenarios
   • Performance optimization and load testing
   • Security testing and vulnerability assessment
   • Cross-platform compatibility validation

2. Production Readiness

   • Docker containerization for consistent deployment
   • Environment configuration management
   • Monitoring and alerting setup
   • Documentation and user training materials

Modern Development Practices

Code Quality & Maintenance

• Clean Code: SOLID principles, clear naming conventions, comprehensive comments
• Testing Strategy: Unit tests (80%+ coverage), integration tests, E2E tests
• Code Reviews: Automated PR checks, peer reviews, security scanning
• Refactoring: Continuous improvement with metrics-driven decisions

Performance Optimization

• Backend: Connection pooling, query optimization, caching strategies
• Frontend: Code splitting, lazy loading, efficient state updates
• Database: Index optimization, query plan analysis, connection tuning
• Network: Request optimization, compression, CDN utilization

Observability & Monitoring

• Logging: Structured logging with correlation IDs across distributed services
• Metrics: Application performance metrics, business metrics, infrastructure metrics
• Tracing: Distributed tracing for cross-service request flows
• Alerting: Proactive monitoring with intelligent alerting rules

Key Deliverables

• Working System: Functional distributed library management system
• Source Code: Well-documented Go backend and Flutter frontend
• Database Scripts: Schema creation and data initialization scripts
• Technical Report: Detailed explanation of distributed concepts implementation
• User Documentation: Guides for both THUTHU and QUANLY users

Enhanced Success Metrics & Validation

Technical Excellence

• Distributed Concepts: All required concepts properly implemented and documented
• Code Quality: 90%+ test coverage, clean architecture, comprehensive documentation
• Performance: Sub-100ms local queries, sub-500ms distributed queries
• Reliability: 99.9% uptime, graceful degradation under failure conditions
• Security: Zero critical vulnerabilities, proper authentication and authorization

User Experience

• Functionality: All user roles can perform designated functions efficiently
• Usability: Intuitive interfaces with proper error handling and feedback
• Responsiveness: Optimal performance across desktop and web platforms
• Accessibility: WCAG 2.1 AA compliance for inclusive design

Academic Requirements

• Distributed Database Theory: Comprehensive implementation of fragmentation, replication, and distributed queries
• Documentation: Detailed technical reports explaining design decisions and trade-offs
• 2PC Implementation: Working demonstration of distributed transaction management
• Transparency: Users interact with system as unified database regardless of distribution

Risk Mitigation & Contingency Planning

Technical Risks

• MSSQL on Parallels: Backup plan using Docker containers or cloud databases
• Network Latency: Implement comprehensive caching and offline capabilities
• Data Inconsistency: Robust conflict resolution and eventual consistency mechanisms
• Performance Issues: Proactive monitoring with automated scaling strategies

Project Management Risks

• Scope Creep: Clear requirements documentation with change control processes
• Time Constraints: Agile development with MVP approach and incremental delivery
• Integration Complexity: Early integration testing with continuous integration pipelines
• Knowledge Gaps: Comprehensive documentation and knowledge sharing sessions

Quality Assurance

• Automated Testing: Comprehensive test suites with high coverage requirements
• Code Reviews: Mandatory peer reviews with automated quality checks
• Performance Testing: Regular load testing and performance benchmarking
• Security Audits: Regular security assessments and vulnerability scanning

This enhanced planning mode ensures your project not only meets academic requirements but also demonstrates industry-standard development practices and modern software engineering principles.