1MEIC08T02 | SPARK - FEUP-MEIC-DS-2024-25/ai4sd GitHub Wiki

SPARK, Sprint Planning with AI for Resource Knowledge is an AI tool created to optimize sprint planning in agile teams, integrating seamlessly with GitHub and Miro to facilitate the organization and visualization of tasks.

Vision

Let's imagine a world where planning sprints is no longer a headache. Well, that world already exists, and it's called SPARK - an artificial intelligence tool that revolutionizes the way we manage sprint planning. It all starts when it connects directly to your GitHub repository, where it does a complete scan of the product backlog. Each task is analyzed by the AI, which considers priorities, dependencies and the team's capacity. With this information, SPARK automatically organizes tasks into optimized sprints with the help of the API of Gemini. But it doesn't stop there. What makes SPARK really innovative is its integration with Miro. All organized tasks are displayed visually on an interactive board, which the whole team can see, collaborate on and adjust in real time. Need to move a task or reorganize the sprint? Just drag and drop. Miro's flexibility combined with SPARK's intelligence makes sprint planning agile and dynamic. Once everthing is in the right place in Miro, SPARK automatically synchronizes everything back to GitHub. This way, your backlog is up to date, the sprints are ready to start and the team is fully aligned. Plan, visualize, adjust and execute - all with the help of AI.

Research

The initial research process included a survey of AI tools aimed at Software Development The analysis focused on identifying solutions that could be used for planning sprints, organizing tasks and optimizing the allocation of development resources. It was then possible to identify both the limitations and strengths of each available solution. On the other hand, we also analyze tools aimed at managing teams in agile projects and their functionalities.

Some of these tools include Jira, Azure DevOps and Asana.

  • Jira, developed by Atlassian, is one of the most widely used tools for agile project management, especially in software development teams. With features such as creating sprints, backlogs and integration with development tools, Jira makes it possible to organize tasks at different stages of the development cycle. It also offers detailed progress reports, delivery predictability and a wide range of plugins, including integrations with AI APIs. This tool can serve as an inspiration for SPARK's functionality, especially with regard to the visualization and automatic organization of tasks.
  • Another example is Azure DevOps, which has a complete set of tools for planning and controlling projects, including agile boards and advanced reports. Azure DevOps allows you to automate workflows through integration with GitHub, as well as providing progress metrics for tracking sprints. Azure DevOps' automation structure and customization options are relevant references for SPARK, especially when it comes to integration with GitHub, which is fundamental to SPARK's proposal of importing tasks from repositories and organizing them automatically.
  • Asana is more focused on organizing tasks and managing teams in a collaborative work environment. Although it's not exclusively a tool for agile development, Asana allows you to set up customized workflows and task lists that adapt to your teams' needs. Integration with APIs and ease of use for teams that are not necessarily technical are aspects that can be useful when designing SPARK. An intuitive and flexible interface, like Asana's, can make SPARK more accessible to a wider user base.

With SPARK we aim to bring together the best of both worlds, AI and sprint planning, building a little on everything that already exists.

Domain Analysis

image

Architecture and Design

image image

Technologies

Django is a framework that uses Python for backend development, which allows for an organized and scalable architecture. It provides a set of high-level tools that facilitate integration with external APIs, data manipulation and the construction of secure and efficient HTTP routes. Django also has an excellent authentication and authorization library, which is essential for ensuring security in interactions with external services such as GitHub and Miro. SPARK integrates three main APIs to fetch data from GitHub, generate sprints with Gemini and display tasks in Miro:

  • GitHub API: We use GitHub's GraphQL API to access project data, including tasks and their details such as title, description, assignees and status. The project key is provided by the user, allowing SPARK to access specific information and display it in the interface.
  • Gemini API: Gemini is an advanced language model that receives the project's task data and suggests which ones should be prioritized in the iteration's backlog. The answer is a list in JSON format that SPARK uses to identify tasks with the greatest impact and automatically classify them.
  • Miro API: SPARK uses Miro's REST API to create and organize stickies on the user's planning board. Each task is represented by a sticky note, with a code that randomly positions the notes on the board and chooses dynamic colors for visual organization.

The user interface design is created in Figma and implemented with CSS. Figma offers a collaborative design environment, enabling the creation of intuitive interfaces aligned with SPARK’s visual style, while CSS ensures a responsive and fluid user experience. SPARK uses Gemini's JSON response to automatically organize sprints; when the sprint button is clicked, tasks are transferred to the Miro board, where a Python function positions the sticky notes in predefined locations to avoid layout conflicts. SPARK uses Gemini's JSON response to organize sprints automatically. When you click on the sprint button, the tasks are moved to the Miro wall, and a Python function analyzes and organizes the sticky notes according to the proposed iterations. In this way, SPARK reduces manual planning time by offering a visual and organized view of priorities directly in Miro. Interactions with GitHub and Miro are authenticated by secure API tokens, preventing unauthorized access. The security of Django's HTTP routes and the use of best practices for storing credentials ensure that SPARK works securely.

Development guide

This section provides a comprehensive guide to setting up, running, and working on this Django project, ensuring that developers and testers have all the information needed to contribute effectively.

Prerequisites

  • Python: Make sure you have Python3 installed. Check your version by running: 
    python3 --version
  • Pipenv is used for dependency management. Install it with: 
    sudo apt install pipenv

Setting up the project

  • Clone the repository:

    git clone [email protected]:FEUP-MEIC-DS-2024-25/T08_G02.git
cd T08_G02/spark

  • Install dependencies and activate the virtual environment:

    pipenv install 

    pipenv shell

Running the project

python3 manage.py runserver

Quality assurance

On the quality side of our software, we will focus on ensuring robustness and functionality through acceptance tests and unit tests.

Unit tests will be applied to specific components of the code, checking that each unit of functionality operates correctly and in isolation. These tests help to identify and correct problems in the early stages of development, which contributes to more reliable and maintainable code.

Acceptance tests will be carried out to ensure that SPARK meets the requirements and expectations we have, validating the system's behavior in real scenarios. With this dual approach, we can align technical quality and user satisfaction.

Current State Overview

What is SPARK capable of at the moment?

  • Create a SPARK account, access our profile and link our Miro token and GitHub account.
  • Log in and out of our account.
  • Create SPARK projects so that we can then plan our Sprints.
  • Extract the tasks from the product backlog with the Github API and then with the Gemini API use the AI to organize the tasks that go into the Sprint.
  • With the Miro API, it takes the information from the PB tasks and creates sticky notes in the Miro Product Backlog.
  • Also with the Miro API, create the tags that were on GitHub in the Miro tasks.
  • Changes Miro's tasks from the Product Backlog to the Iteration Backlog based on what the Gemini API has provided and is receptive to changes from the user.
  • Exports the Miro information from the tasks in the Iteration Backlog.

What's still missing?

  • At the moment it is not yet possible to create the Miro Board template.
  • We were unable to change the tasks on GitHub based on the information exported from Miro.
  • The frontend is not yet developed ;

Here's a short demonstration of what SPARK is already capable of and our work until the end of Sprint 1:

Design sem nome

Sprint Retrospectives

Sprint 0

The positive points highlighted were the open communication between everyone, the constant feedback given by all the members and the various short meetings to show the work done, ask for feedback and get everyone up to speed.

Focusing now on the less positive points, we'd like to point out that at an early stage there was a certain amount of disorganization, which we think is normal as we were at the beginning of the project and it was new. Another point is to rethink the division of tasks between the members. We have reflected on this and think that the work was concentrated on a few members, which may have led to a certain overload and we don't want this to happen again. Finally, we think it's important to establish fixed deadlines. Up until now we've been working to targets rather than deadlines, which has gone well, but we think that in order to boost the work and make it flow better we should have a fixed calendar with fixed dates for each key element of the project.

Some proposals for improvement discussed include defining clear objectives among the members and following our plan for Sprint 1, the daily meetings, cross trainings and constant sharing of feedback as has happened so far.

Sprint 1

At the end of Sprint 1 we're happy with the work completed, the backend is well advanced and we're aware that during Sprint 2 we have to focus on the front end.

We were a little ambitious in the tasks we set ourselves for Sprint 1, but most of them were completed successfully. The good performance of the team was maintained as well as fluid, open and efficient communication.

For Sprint 2 we aim to start developing the overall: AI4SD project with a focus on the Jarvis component.

Sprint 2

At the end of Sprint 2, SPARK is already fully functional in terms of features, but in this sprint we were unable to implement the frontend.

During this sprint, the team suffered a few setbacks, with a member leaving, which made work a little difficult during this period, but quickly, after a conversation, we came up with a strategic plan to get back to good work.

Contributions

This work was carried out equally by all members.