AI-powered developer productivity platform that eliminates context switching

Continuum is a serverless Atlassian Forge application that aggregates developer work across Jira, Confluence, Bitbucket, GitHub, and GitLab into a unified, AI-powered dashboard. Built for the Codegeist 2025 competition, Continuum runs entirely on Atlassian infrastructure with zero data egress, qualifying for "Runs on Atlassian" compliance.

• 🎯 Priority Queue: Intelligent priority scoring (0-100+) across all platforms based on age, impact, deadlines, and blocker status
• 🔀 PR Dashboard: Unified view of pull requests from GitHub, GitLab, and Bitbucket with cross-platform filtering and sorting
• 🧠 Context Restoration: AI-powered context recovery with last actions, changes detection, and suggested next steps
• 🎧 Focus Mode: Time-based notification batching with priority thresholds to maintain deep work sessions
• 🤖 Rovo AI Agent: 5 custom AI actions for intelligent productivity assistance
• 🚧 Bottleneck Detection: Proactive identification of stale PRs, stuck tickets, and blocker pile-ups with team health scoring
• 📊 Activity Feed: Real-time aggregated activity stream across all platforms
• 👥 My Work: Customizable grouping by status, project, or priority

• Serverless Architecture: 100% Forge-based with no external servers
• Parallel Data Fetching: Simultaneous platform queries with graceful degradation
• Smart Caching: Multi-layer caching with configurable TTLs (70%+ hit rate)
• OAuth Security: Secure token management via Forge External Authentication
• Property-Based Testing: Comprehensive correctness validation with 100+ iterations per property

• Quick Start
• Prerequisites
• Installation
• OAuth Configuration
• Development
• Architecture
• Testing
• Deployment
• Documentation
• License

# 1. Clone and install dependencies
git clone <repository-url>
cd continuum-platform
npm install
cd src/frontend && npm install && cd ../..

# 2. Configure OAuth apps (see OAuth Configuration section)

# 3. Set environment variables
cp .env.example .env
# Edit .env with your OAuth credentials

# 4. Build and deploy
npm run build
forge login
forge deploy -e development
forge install --product jira

# 5. Access Continuum in Jira → Apps → Continuum

• Node.js: >= 18.0.0 (LTS recommended)
• npm: >= 9.0.0 or yarn: >= 1.22.0
• Forge CLI: Install globally with npm install -g @forge/cli
• Atlassian Account: With Forge developer access

• GitHub Account: For GitHub OAuth integration
• GitLab Account: For GitLab OAuth integration
• Jira Cloud Site: For testing and deployment
• Confluence Cloud: For document integration

• VS Code: With TypeScript and ESLint extensions
• Git: For version control
• Postman/Insomnia: For API testing

git clone <repository-url>
cd continuum-platform

# Install root dependencies
npm install

# Install frontend dependencies
cd src/frontend
npm install
cd ../..

# Check Node version
node --version  # Should be >= 18.0.0

# Check Forge CLI
forge --version

# Run type checking
npm run type-check

# Run linting
npm run lint

Continuum requires OAuth apps for GitHub and GitLab integration. Follow these detailed steps:

1. Navigate to GitHub Settings

   • Go to https://github.com/settings/developers
   • Click "OAuth Apps" in the left sidebar
   • Click "New OAuth App"

2. Configure Application

   • Application name: Continuum Development (or your preferred name)
   • Homepage URL: https://developer.atlassian.com
   • Application description: AI-powered developer productivity platform
   • Authorization callback URL:

     https://developer.atlassian.com/console/install/[your-app-id]
     

     Note: Replace [your-app-id] with your actual Forge app ID (found after first deployment)

3. Generate Client Secret

   • After creating the app, click "Generate a new client secret"
   • Important: Copy the secret immediately (it won't be shown again)

4. Copy Credentials

   • Copy the Client ID
   • Copy the Client Secret (from step 3)

5. Required Scopes

   • repo: Full control of private repositories
   • user: Read user profile data
   • user:email: Access user email addresses

1. Navigate to GitLab Applications

   • Go to https://gitlab.com/-/profile/applications
   • Or: GitLab → Preferences → Applications

2. Create New Application

   • Name: Continuum Development
   • Redirect URI:

     https://developer.atlassian.com/console/install/[your-app-id]
     

   • Confidential: ✅ Checked
   • Scopes: Select the following:
     • ✅ api: Access the authenticated user's API
     • ✅ read_user: Read the authenticated user's personal information

3. Save Application

   • Click "Save application"
   • Copy the Application ID
   • Copy the Secret

1. Create Environment File

   cp .env.example .env

2. Edit .env File

   # GitHub OAuth Configuration
   GITHUB_CLIENT_ID=your_github_client_id_here
   GITHUB_CLIENT_SECRET=your_github_client_secret_here
   
   # GitLab OAuth Configuration
   GITLAB_CLIENT_ID=your_gitlab_application_id_here
   GITLAB_CLIENT_SECRET=your_gitlab_secret_here

3. Verify Configuration

   # Ensure .env is in .gitignore
   grep ".env" .gitignore
   
   # Check environment variables are loaded
   cat .env

For production deployment, create separate OAuth apps:

1. GitHub Production App

   • Use production callback URL
   • Use descriptive name: Continuum Production
   • Store credentials securely

2. GitLab Production App

   • Use production callback URL
   • Use descriptive name: Continuum Production
   • Store credentials securely

3. Update Forge Environment Variables

   forge variables set GITHUB_CLIENT_ID <prod-id> -e production
   forge variables set GITHUB_CLIENT_SECRET <prod-secret> -e production
   forge variables set GITLAB_CLIENT_ID <prod-id> -e production
   forge variables set GITLAB_CLIENT_SECRET <prod-secret> -e production

continuum-platform/
├── .kiro/
│   └── specs/
│       └── continuum-platform/      # Specification documents
│           ├── requirements.md       # EARS-compliant requirements
│           ├── design.md            # Comprehensive design document
│           └── tasks.md             # Implementation task list
├── src/
│   ├── index.ts                     # Main resolver entry point
│   ├── types/
│   │   └── index.ts                 # TypeScript type definitions
│   ├── services/                    # Business logic layer
│   │   ├── priorityScoring.ts      # Priority calculation algorithm
│   │   ├── jiraIntegration.ts      # Jira API integration
│   │   ├── githubIntegration.ts    # GitHub API integration
│   │   ├── gitlabIntegration.ts    # GitLab API integration
│   │   ├── bitbucketIntegration.ts # Bitbucket API integration
│   │   ├── confluenceIntegration.ts # Confluence API integration
│   │   ├── dataAggregation.ts      # Multi-platform aggregation
│   │   ├── contextRestoration.ts   # Context recovery logic
│   │   ├── notificationBatching.ts # Focus mode & batching
│   │   └── bottleneckDetection.ts  # Bottleneck analysis
│   ├── rovo/
│   │   └── actions.ts              # Rovo AI agent actions
│   ├── utils/                      # Shared utilities
│   │   ├── storage.ts              # Forge storage wrapper
│   │   ├── cache.ts                # Caching with TTL
│   │   ├── auth.ts                 # OAuth helpers
│   │   ├── errors.ts               # Error handling
│   │   ├── formatting.ts           # Data formatting
│   │   ├── logger.ts               # Logging utility
│   │   └── constants.ts            # App constants
│   ├── __tests__/                  # Backend tests
│   │   ├── *.test.ts               # Unit tests
│   │   └── *.integration.test.ts   # Integration tests
│   └── frontend/                   # React frontend
│       ├── public/
│       │   └── index.html
│       ├── src/
│       │   ├── components/         # React components
│       │   ├── hooks/              # Custom React hooks
│       │   ├── context/            # Global state
│       │   ├── styles/             # CSS files
│       │   ├── App.tsx             # Root component
│       │   └── index.tsx           # Entry point
│       ├── package.json
│       └── tsconfig.json
├── docs/                           # Documentation
│   ├── ARCHITECTURE.md             # Architecture details
│   ├── API.md                      # API documentation
│   ├── USER_GUIDE.md               # User guide
│   └── PRIORITY_ALGORITHM.md       # Priority scoring details
├── manifest.yml                    # Forge app manifest
├── package.json                    # Root dependencies
├── tsconfig.json                   # TypeScript config
├── jest.config.js                  # Jest configuration
├── .eslintrc.json                  # ESLint rules
├── .env.example                    # Environment template
└── README.md                       # This file

# Build
npm run build                # Build frontend
npm run build:frontend       # Build frontend only

# Testing
npm test                     # Run all tests
npm run test:watch           # Run tests in watch mode
npm run test:coverage        # Generate coverage report

# Code Quality
npm run lint                 # Check for linting errors
npm run lint:fix             # Fix linting errors automatically
npm run type-check           # Run TypeScript type checking

# Forge Commands
forge deploy                 # Deploy to default environment
forge deploy -e development  # Deploy to development
forge deploy -e production   # Deploy to production
forge install                # Install app to site
forge logs                   # View logs
forge logs --follow          # Stream logs in real-time
forge tunnel                 # Start development tunnel
forge eligibility            # Check "Runs on Atlassian" compliance

1. Start Development Tunnel (Optional)

   forge tunnel

   This allows you to test changes without deploying.

2. Make Code Changes

   • Edit backend code in src/
   • Edit frontend code in src/frontend/src/

3. Run Tests

   npm test

4. Build Frontend

   npm run build

5. Deploy Changes

   forge deploy -e development

6. View Logs

   forge logs --follow

• Check Logs: Use forge logs --follow to see real-time logs
• Console Logging: Add console.log() statements (visible in forge logs)
• Type Errors: Run npm run type-check to catch TypeScript issues
• Lint Errors: Run npm run lint before committing
• Test Failures: Run npm test to identify broken functionality
• OAuth Issues: Verify callback URLs match exactly
• Cache Issues: Clear cache by incrementing version in manifest.yml

┌─────────────────────────────────────────────────────────────┐
│                     React Frontend (UI)                      │
│  ┌──────────┬──────────┬──────────┬──────────┬──────────┐  │
│  │Priority  │   PR     │  My Work │ Activity │ Settings │  │
│  │  Queue   │Dashboard │          │   Feed   │          │  │
│  └──────────┴──────────┴──────────┴──────────┴──────────┘  │
└────────────────────────┬────────────────────────────────────┘
                         │ Forge Bridge (invoke)
┌────────────────────────┴────────────────────────────────────┐
│                  Forge Resolver Layer                        │
│  ┌──────────────────────────────────────────────────────┐  │
│  │ 14 Resolvers (getPriorityItems, restoreContext...)   │  │
│  └──────────────────────────────────────────────────────┘  │
└────────────────────────┬────────────────────────────────────┘
                         │
┌────────────────────────┴────────────────────────────────────┐
│                     Service Layer                            │
│  ┌──────────┬──────────┬──────────┬──────────┬──────────┐  │
│  │Priority  │  Jira    │  GitHub  │  GitLab  │Bitbucket │  │
│  │ Scoring  │Integration│Integration│Integration│Integration│ │
│  └──────────┴──────────┴──────────┴──────────┴──────────┘  │
│  ┌──────────┬──────────┬──────────┬──────────┬──────────┐  │
│  │Confluence│  Data    │ Context  │Notification│Bottleneck│  │
│  │Integration│Aggregation│Restoration│ Batching │Detection │  │
│  └──────────┴──────────┴──────────┴──────────┴──────────┘  │
└────────────────────────┬────────────────────────────────────┘
                         │
┌────────────────────────┴────────────────────────────────────┐
│                  External APIs & Storage                     │
│  ┌──────────┬──────────┬──────────┬──────────┬──────────┐  │
│  │  Jira    │Confluence│ GitHub   │  GitLab  │Bitbucket │  │
│  │   API    │   API    │   API    │   API    │   API    │  │
│  └──────────┴──────────┴──────────┴──────────┴──────────┘  │
│  ┌──────────────────────────────────────────────────────┐  │
│  │           Forge Storage (Encrypted)                   │  │
│  └──────────────────────────────────────────────────────┘  │
└─────────────────────────────────────────────────────────────┘

1. Serverless-First: All code runs on Forge infrastructure
2. Parallel Processing: Fetch from all platforms simultaneously
3. Graceful Degradation: Continue working if one platform fails
4. Smart Caching: Multi-layer caching with TTL validation
5. Security by Design: OAuth tokens never leave Forge
6. Type Safety: Full TypeScript coverage
7. Testability: Property-based and unit testing

1. User interacts with React UI
2. Component invokes backend resolver via Forge Bridge
3. Resolver checks cache (if applicable)
4. Service layer fetches from external APIs in parallel
5. Data normalized to common schema
6. Priority scores calculated
7. Results cached with TTL
8. Response returned to frontend
9. UI updates with new data

For detailed architecture documentation, see docs/ARCHITECTURE.md.

Continuum employs a comprehensive testing strategy with multiple layers:

Test individual functions and components in isolation.

# Run all unit tests
npm test

# Run specific test file
npm test -- priorityScoring.test.ts

# Run tests in watch mode
npm run test:watch

# Generate coverage report
npm run test:coverage

Coverage Areas:

• Priority scoring algorithm
• Data normalization functions
• Filter and sort logic
• Cache TTL validation
• Settings merge logic
• Date/time calculations

Test universal properties across 100+ random inputs.

# Property tests are included in npm test
npm test

Coverage Areas:

• Priority scoring with random work items
• Data aggregation with random platform combinations
• Filter operations with random data sets
• Cache behavior with random timestamps
• Settings validation with random configurations

Example Property:

// Property 2: Priority score validity
// For any work item, the calculated priority score should be non-negative
it('should always return non-negative priority scores', () => {
  fc.assert(
    fc.property(workItemArbitrary, (item) => {
      const score = calculatePriorityScore(item);
      return score >= 0;
    }),
    { numRuns: 100 }
  );
});

Test resolver → service → API flows with mocked external APIs.

# Run integration tests
npm test -- integration.test.ts

Coverage Areas:

• Complete priority queue load
• Context restoration with related artifacts
• Focus mode filtering scenarios
• Multi-platform data aggregation

Test complete user workflows (manual testing recommended).

Test Scenarios:

• New user completes setup wizard
• User connects GitHub and sees PRs
• User enables focus mode
• User applies filters and sees correct results
• User restores context for a task

• Unit Test Coverage: > 80%
• Property Test Coverage: All correctness properties from design doc
• Integration Test Coverage: All critical user flows
• E2E Test Coverage: All major features

# Login to Forge
forge login

# Deploy to development environment
forge deploy -e development

# Install to Jira site
forge install --product jira

# View logs
forge logs --follow

# Set production environment variables
forge variables set GITHUB_CLIENT_ID <prod-id> -e production
forge variables set GITHUB_CLIENT_SECRET <prod-secret> -e production
forge variables set GITLAB_CLIENT_ID <prod-id> -e production
forge variables set GITLAB_CLIENT_SECRET <prod-secret> -e production

# Deploy to production
forge deploy -e production

# Install to production site
forge install --product jira -e production

• All tests passing (npm test)
• No linting errors (npm run lint)
• No type errors (npm run type-check)
• Frontend built (npm run build)
• Environment variables configured
• OAuth apps created for target environment
• Forge eligibility check passed (forge eligibility)
• Deployment successful (forge deploy)
• App installed to site (forge install)
• Manual smoke testing completed

# View real-time logs
forge logs --follow

# View logs for specific function
forge logs --function get-priority-items

# View logs with filter
forge logs --filter "ERROR"

• ARCHITECTURE.md: Detailed architecture and design decisions
• API.md: Complete API documentation for all resolvers and services
• USER_GUIDE.md: End-user guide for all features
• PRIORITY_ALGORITHM.md: Detailed explanation of priority scoring algorithm

• requirements.md: EARS-compliant requirements
• design.md: Comprehensive design document with correctness properties
• tasks.md: Implementation task list

This app is designed to be "Runs on Atlassian" compliant:

• ✅ No remote servers: All code runs on Forge
• ✅ All data processing in Forge functions: No external data processing
• ✅ OAuth via Forge External Authentication: Secure token management
• ✅ Encrypted storage via Forge Storage API: All data encrypted at rest

Verify compliance:

forge eligibility

Expected output:

Runs on Atlassian: ELIGIBLE

MIT License - see LICENSE file for details

Contributions are welcome! Please read the contributing guidelines before submitting pull requests.

For issues and questions:

• Open an issue in the repository
• Check the User Guide
• Review the API Documentation
• Contact the development team

This project was built for the Codegeist 2025 competition, competing in:

• Main Category: Best Overall App
• Bonus Prize: Best Rovo Apps
• Bonus Prize: Best Runs on Atlassian Apps

Built with ❤️ using Atlassian Forge and Rovo AI