diff --git a/.github/agents/confluenceAgent.agent.md b/.github/agents/confluenceAgent.agent.md
new file mode 100644
index 0000000..b2e0ce9
--- /dev/null
+++ b/.github/agents/confluenceAgent.agent.md
@@ -0,0 +1,355 @@
+---
+name: confluenceAgent
+description: Describe what this custom agent does and when to use it.
+argument-hint: The inputs this agent expects, e.g., "a task to implement" or "a question to answer".
+# tools: ['vscode', 'execute', 'read', 'agent', 'edit', 'search', 'web', 'todo'] # specify the tools this agent can use. If not set, all enabled tools are allowed.
+---
+
+Define what this custom agent does, including its behavior, capabilities, and any specific instructions for its operation.
+
+# Code Style Guide - Creedengo
+
+- [Code Style Guide - Creedengo](#code-style-guide---creedengo)
+  - [Introduction](#introduction)
+  - [Source File Basics](#source-file-basics)
+    - [File encoding: UTF-8](#file-encoding-utf-8)
+    - [Indentation](#indentation)
+  - [Source file structure](#source-file-structure)
+    - [Import statements](#import-statements)
+    - [Java source file organization](#java-source-file-organization)
+  - [Formatting](#formatting)
+    - [Braces](#braces)
+      - [Block-like constructs: K\&R style](#block-like-constructs-kr-style)
+    - [Line wrapping](#line-wrapping)
+    - [Blank Lines](#blank-lines)
+  - [Class declaration](#class-declaration)
+  - [Naming](#naming)
+    - [Constant names](#constant-names)
+    - [Variable names](#variable-names)
+  - [Programming Practices](#programming-practices)
+    - [File history](#file-history)
+    - [Organization of setter methods](#organization-of-setter-methods)
+    - [Ternary Operator](#ternary-operator)
+    - [Null Checks](#null-checks)
+    - [Use of @Override](#use-of-override)
+    - [Utility classes](#utility-classes)
+    - [Field and method references](#field-and-method-references)
+    - [Local variable type inference](#local-variable-type-inference)
+    - [Some rules from experience](#some-rules-from-experience)
+      - [Protections against ClassCast exceptions](#protections-against-classcast-exceptions)
+  - [Javadoc](#javadoc)
+    - [Javadoc formatting](#javadoc-formatting)
+  - [Tests](#tests)
+    - [Testing Framework](#testing-framework)
+    - [Naming](#naming-1)
+    - [Assertions](#assertions)
+    - [Mocking](#mocking)
+    - [Some rules from experience](#some-rules-from-experience-1)
+      - [Unit tests](#unit-tests)
+
+## Introduction
+
+This document defines the coding standards for source files in the plugin. It is primarily intended for the plugin team but can be used as a reference by contributors.
+
+The structure of this document is based on the [Google Java Style](https://google.github.io/styleguide/javaguide.html) reference and [Springframework Code Style](https://github.com/spring-projects/spring-framework/wiki/Code-Style) and is a _work in progress_.
+
+## Source File Basics
+
+### File encoding: UTF-8
+
+Source files must be encoded using `UTF-8`.
+
+### Indentation
+
+> In Progresss
+
+## Source file structure
+
+A source file consists of the following, in this exact order:
+
+- Package statement
+- Import statements
+- Exactly one top-level class
+
+Exactly one blank line separates each of the above sections.
+
+### Import statements
+
+> In Progresss
+
+### Java source file organization
+
+The following governs how the elements of a source file are organized:
+
+1. static fields
+1. normal fields
+1. constructors
+1. (private) methods called from constructors
+1. static factory methods
+1. JavaBean properties (i.e., getters and setters)
+1. method implementations coming from interfaces
+1. private or protected templates that get called from method implementations coming from interfaces
+1. other methods
+1. `equals`, `hashCode`, and `toString`
+
+Note that private or protected methods called from method implementations should be placed immediately below the methods where they're used. In other words if there 3 interface method implementations with 3 private methods (one used from each), then the order of methods should include 1 interface and 1 private method in sequence, not 3 interface and then 3 private methods at the bottom.
+
+Above all, the organization of the code should feel _natural_.
+
+## Formatting
+
+### Braces
+
+#### Block-like constructs: K&R style
+
+Braces mostly follow the _Kernighan and Ritchie style_ (a.k.a., "Egyptian brackets") for nonempty blocks and block-like constructs:
+
+- No line break before the opening brace but prefixed by a single space
+- Line break after the opening brace
+- Line break before the closing brace
+- Line break after the closing brace if that brace terminates a statement or the body of a method, constructor, or named class
+- Line break before else, catch and finally statements
+
+Example:
+
+```java
+return new MyClass() {
+  @Override
+  public void method() {
+    if (condition()) {
+      something();
+    }
+    else {
+      try {
+        alternative();
+      }
+      catch (ProblemException ex) {
+        recover();
+      }
+    }
+  }
+};
+```
+
+### Line wrapping
+
+90 characters is the _preferred_ line length we aim for. In some cases the preferred length can be achieved by refactoring code slightly. In other cases it's just not possible.
+
+90 is not a hard limit. Lines between 90-105 are perfectly acceptable in many cases where it aids readability and where wrapping has the opposite effect of reducing readability. This is a judgement call and it's also important to seek consistency. Many times you can learn by looking how specific situations are handled in other parts of the code.
+
+Lines between 105-120 are allowed but discouraged and should be few.
+
+No lines should exceed 120 characters.
+
+The one big exception to the above line wrapping rules is Javadoc where we aim to wrap around 80 characters for maximum readability in all kinds of contexts, e.g. reading on Github, on your phone, etc.
+
+When wrapping a lengthy expression, 90 characters is the length at which we aim to wrap. Put the separator symbols at the end of the line rather on the next line (comma separated arguments, etc). For instance:
+
+```java
+if (thisLengthyMethodCall(param1, param2) && anotherCheck() && yetAnotherCheck()) {
+  // ....
+}
+```
+
+### Blank Lines
+
+Add two blank lines before the following elements:
+
+- `static {}` block
+- Fields
+- Constructors
+- Inner classes
+
+Add one blank line after a method signature that is multiline, i.e.
+
+```java
+@Override
+protected Object invoke(FooBarOperationContext context, AnotherSuperLongName name) {
+  // code here
+}
+```
+
+For inner-classes, extra blank lines around fields and constructors are typically not
+added as the inner class is already separated by 2 lines, unless the inner class is
+more substantial in which case the 2 extra lines could still help with readability.
+
+## Class declaration
+
+Try as much as possible to put the `implements`, `extends` section of a class declaration on the same line as the class itself.
+
+Order the classes so that the most important comes first.
+
+## Naming
+
+### Constant names
+
+Constant names use `CONSTANT_CASE`: all uppercase letters, with words separated by underscores.
+
+Every constant is a `static final` field, but not all `static final` fields are constants. Constant case should therefore be chosen only if the field **is really** a constant.
+
+Example:
+
+```java
+// Constants
+private static final Object NULL_HOLDER = new NullHolder();
+public static final int DEFAULT_PORT = -1;
+
+// Not constants
+private static final ThreadLocal<Executor> executorHolder = new ThreadLocal<Executor>();
+private static final Set<String> internalAnnotationAttributes = new HashSet<String>();
+```
+
+### Variable names
+
+Avoid using single characters as variable names. For instance prefer `Method method` to `Method m`.
+
+## Programming Practices
+
+### File history
+
+- A file should look like it was crafted by a single author, not like a history of changes
+- Don't artificially spread things out that belong together
+
+### Organization of setter methods
+
+Choose wisely where to add a new setter method; it should not be simply added at the end of the list. Perhaps the setter is related to another setter or relates to a group. In that case it should be placed near related methods.
+
+- Setter order should reflect order of importance, not historical order
+- Ordering of _fields_ and _setters_ should be **consistent**
+
+### Ternary Operator
+
+Wrap the ternary operator within parentheses, i.e. `return (foo != null ? foo : "default");`
+
+Also make sure that the _not null_ condition comes first.
+
+### Null Checks
+
+Use the `org.springframework.util.Assert.notNull` static method to check that a method argument is not `null`. Format the exception message so that the name of the parameter comes first with its first character capitalized, followed by "_must not be null_". For instance
+
+```java
+public void handle(Event event) {
+    Assert.notNull(event, "Event must not be null");
+    //...
+}
+```
+
+### Use of @Override
+
+Always add `@Override` on methods overriding or implementing a method declared in a super type.
+
+### Utility classes
+
+A class that is only a collection of static utility methods must be named with a `Utils` suffix, must have a `private` default constructor, and must be `abstract`. Making the class `abstract` and providing a `private` _default_ constructor prevent anyone from instantiating it. For example:
+
+```java
+public abstract MyUtils {
+
+    private MyUtils() {
+        /* prevent instantiation */
+    }
+
+    // static utility methods
+}
+```
+
+### Field and method references
+
+A field of a class should _always_ be referenced using `this`. A method of class, however, should never be referenced using `this`.
+
+### Local variable type inference
+
+The use of `var` for variable declarations (_local variable type inference_) is not permitted. Instead, declare variables using the concrete type or interface (where applicable).
+
+### Some rules from experience
+
+#### Protections against ClassCast exceptions
+
+From experience with issue [#42](https://github.com/green-code-initiative/creedengo-rules-specifications/issues/42), when an exception occurs during Sonar analysis with maven command, the consequence is a crash. If this phase is launched in a CI/CD pipeline, this crash will block the pipeline. Thus, our plugins will be deleted until next corrections.
+
+Please, make a maximum of controls in the code to avoid ClassCast exceptions and thus, avoid uninstalling our plugin from SonarQube.
+
+## Javadoc
+
+### Javadoc formatting
+
+The following template summarizes a typical use for the Javadoc of a method.
+
+```java
+/**
+ * Parse the specified {@link Element} and register the resulting
+ * {@link BeanDefinition BeanDefinition(s)}.
+ * <p>Implementations must return the primary {@link BeanDefinition} that results
+ * from the parsing if they will ever be used in a nested fashion (for example as
+ * an inner tag in a {@code <property/>} tag). Implementations may return
+ * {@code null} if they will <strong>not</strong> be used in a nested fashion.
+ * @param element the element that is to be parsed into one or more {@link BeanDefinition BeanDefinitions}
+ * @param parserContext the object encapsulating the current state of the parsing process;
+ * provides access to a {@link org.springframework.beans.factory.support.BeanDefinitionRegistry}
+ * @return the primary {@link BeanDefinition}
+ */
+BeanDefinition parse(Element element, ParserContext parserContext);
+```
+
+In particular, please note:
+
+- Use an imperative style (i.e. _Return_ and not _Returns_) for the first sentence.
+- No blank lines between the description and the parameter descriptions.
+- If the description is defined with multiple paragraphs, start each of them with `<p>`.
+- If a parameter description needs to be wrapped, do not indent subsequent lines (see `parserContext`).
+
+The Javadoc of a class has some extra rules that are illustrated by the sample below:
+
+```java
+/*
+ * Interface used by the {@link DefaultBeanDefinitionDocumentReader} to handle custom,
+ * top-level (directly under {@code <beans/>}) tags.
+ *
+ * <p>Implementations are free to turn the metadata in the custom tag into as many
+ * {@link BeanDefinition BeanDefinitions} as required.
+ *
+ * <p>The parser locates a {@link BeanDefinitionParser} from the associated
+ * {@link NamespaceHandler} for the namespace in which the custom tag resides.
+ *
+ * @author Rob Harrop
+ * @since 2.0
+ * @see NamespaceHandler
+ * @see AbstractBeanDefinitionParser
+ */
+```
+
+- The order of tags for class-level Javadoc is: `@author`, `@since`, `@param`, `@see`, `@deprecated`.
+- The order of tags for method-level Javadoc is: `@param`, `@return`, `@throws`, `@since`, `@see`, `@deprecated`.
+- In contrast to method-level Javadoc, the paragraphs of a class description _are_ separated by blank lines.
+
+The following are additional general rules to apply when writing Javadoc:
+
+- Use `{@code}` to wrap code statements or values such as `null`.
+- If a type is only referenced by a `{@link}` element, use the fully qualified name in order to avoid an unnecessary `import` declaration.
+
+## Tests
+
+### Testing Framework
+
+Tests must be written using JUnit Jupiter (a.k.a., JUnit 5).
+
+The only exceptions to the above rule are test classes in the `spring-test` module that specifically test Spring's integration with JUnit 4 and TestNG.
+
+### Naming
+
+Each test class name must end with a `Tests` suffix.
+
+### Assertions
+
+Use AssertJ for assertions.
+
+### Mocking
+
+Use the BDD Mockito support.
+
+### Some rules from experience
+
+#### Unit tests
+
+Unit test are mandatory. If you can, use Test Driven Development method to write your tests.
+Check coverage of your tests with SoanrQube integration of our code.
diff --git a/.github/copilot-instructions.md b/.github/copilot-instructions.md
new file mode 100644
index 0000000..18a4b15
--- /dev/null
+++ b/.github/copilot-instructions.md
@@ -0,0 +1,129 @@
+# Creedengo Dashboard — Agent Instructions
+
+## Project Overview
+
+**Creedengo Dashboard** is a Green IT / sustainable code dashboard (Green Code Initiative).
+It displays the sustainability impact of un-remediated SonarQube issues and helps prioritize fixes.
+The same Vue 3 app can be embedded in SonarQube, VSCode, Confluence, or any other host.
+
+---
+
+## Architecture
+
+Monorepo managed with **pnpm workspaces** and **Turborepo**. Three workspace scopes:
+
+| Folder     | Contents                                                                                          |
+| ---------- | ------------------------------------------------------------------------------------------------- |
+| `apps/`    | Deployable applications (Vue app, SonarQube plugin, Confluence plugin, VSCode extension)          |
+| `shared/`  | Internal libraries (`@creedengo/core-services`, `@creedengo/sonar-services`, `@creedengo/vue-ui`) |
+| `configs/` | Shared configs (ESLint, Playwright, Vitest)                                                       |
+
+Key files:
+
+- [turbo.json](../turbo.json) — task graph and caching
+- [pnpm-workspace.yaml](../pnpm-workspace.yaml) — workspace definition
+- [apps/confluence-plugin/pom.xml](../apps/confluence-plugin/pom.xml) — Atlassian OSGi bundle
+- [apps/sonar-plugin/pom.xml](../apps/sonar-plugin/pom.xml) — SonarQube plugin
+
+---
+
+## Build & Test
+
+### JavaScript / TypeScript (all packages)
+
+```sh
+pnpm install          # install dependencies (pnpm only — enforced via preinstall)
+turbo build           # build all packages in topological order
+turbo dev             # dev mode with hot-reload
+turbo test:unit       # Vitest unit tests across all packages
+turbo test:e2e        # Playwright E2E tests (requires prior build)
+turbo lint            # ESLint across all packages
+pnpm ci               # lint + test:unit + test:e2e (full CI)
+```
+
+Node.js `22.17.1` is required (`.nvmrc`). Use `pnpm`, never `npm` or `yarn`.
+
+### Confluence plugin (Atlassian SDK + Maven)
+
+```sh
+atlas-run             # Start Confluence locally with the plugin loaded
+atlas-debug           # Same in debug mode (port 5005)
+atlas-mvn package     # Quick reload (hot-swap without restart)
+mvn -B verify         # Full build + tests
+mvn -B test           # Tests only
+```
+
+See VS Code tasks in `.vscode/` for `atlas-run`, `atlas-debug`, `quick-reload`.
+
+### SonarQube plugin (Maven + embedded frontend)
+
+```sh
+mvn -B verify         # Full build: installs Node locally via frontend-maven-plugin, bundles Vue app, then packages JAR
+mvn -B test           # Tests only
+```
+
+---
+
+## Java / Atlassian Plugin Development
+
+### Confluence plugin specifics
+
+- **Packaging**: `atlassian-plugin` (OSGi bundle via AMPS `9.1.1`)
+- **Java version**: source/target `1.8`
+- **Target**: Confluence `8.5.4`
+- **DI**: `atlassian-spring-scanner 2.2.4` — use `@Scanned` on implementations, `@ComponentImport` to import Atlassian components
+- **Tests**: JUnit `4.10` + `atlassian-plugins-osgi-testrunner`
+- **OSGi export**: only `org.greencodeinitiative.creedengo.confluence.plugin.api`
+
+Package structure under `org.greencodeinitiative.creedengo.confluence.plugin`:
+
+```
+api/        ← public OSGi interfaces
+impl/       ← Spring-scanned implementations
+macro/      ← Confluence macros (Dashboard, EcoScore, PriorityRulesMacro)
+service/    ← business logic (ScoreService, PriorityRulesService)
+sonar/      ← SonarQube HTTP client and API sub-calls
+  api/      ← per-endpoint API classes (issues, measures, branches, rules…)
+```
+
+- All macros extend `BaseMacro` and use `MacroHelper` for common rendering logic.
+- `SonarClient` is the HTTP entry point; domain-specific calls are in `sonar/api/`.
+- GPL-3 license headers are **mandatory** on every `.java` file (enforced by `license-maven-plugin` in the sonar-plugin; apply the same convention in the confluence-plugin).
+
+### SonarQube plugin specifics
+
+- **Packaging**: `sonar-plugin` (fat JAR via `maven-shade-plugin`)
+- **Java**: compile `11`, JDK min `17`
+- **SonarQube API**: `9.14.0.375`
+- **Tests**: JUnit Jupiter `5.10.3` + Mockito `5.12` + AssertJ `3.26`
+- **Coverage**: JaCoCo `0.8.11`
+- Plugin entry point: `org.greencodeinitiative.creedengo.dashboard.DashboardPlugin`
+
+---
+
+## Frontend Conventions
+
+- **Vue 3** (Composition API + `<script setup>`)
+- **Vite 7** as bundler; build output is fixed to `dist/view.js` + `dist/view.css`
+- `@` alias resolves to `./src` in `apps/vue-app`
+- API layer is split: `@creedengo/core-services` (provider-agnostic) → `@creedengo/sonar-services` (SonarQube-specific)
+- Mocking via **MSW** (`public/mockServiceWorker.js`)
+- Unit tests: Vitest + `@vue/test-utils` + jsdom
+- E2E tests: Playwright (config in `configs/playwright-config`)
+
+---
+
+## Code Style
+
+- See [CODE_STYLE.md](../CODE_STYLE.md) and [CONTRIBUTING.md](../CONTRIBUTING.md)
+- Commit messages follow **Conventional Commits** (`commitlint.config.js`)
+- Shared ESLint config: `@creedengo/eslint-config` (`configs/eslint-config/`)
+- Changesets (`pnpm changeset`) for versioning JS packages
+
+---
+
+## Integration Points
+
+- **SonarQube/SonarCloud** REST API consumed by `sonar/` Java layer and `@creedengo/sonar-services`
+- The Vue app is embedded at runtime: served as static assets inside the SonarQube JAR or Confluence OBR, injected as a webview in VSCode
+- `frontend-maven-plugin` in `apps/sonar-plugin/pom.xml` bridges the JS and Java builds
diff --git a/.github/instructions/java.instructions.md b/.github/instructions/java.instructions.md
new file mode 100644
index 0000000..6164cce
--- /dev/null
+++ b/.github/instructions/java.instructions.md
@@ -0,0 +1,428 @@
+---
+description: "Guidelines for building Java base applications"
+applyTo: "**/*.java"
+---
+
+# Java Development
+
+## General Instructions
+
+- First, prompt the user if they want to integrate static analysis tools (SonarQube, PMD, Checkstyle) into their project setup.
+  - If yes, document a recommended static-analysis setup.
+    - Prefer SonarQube/SonarCloud (SonarLint in IDE + `sonar-scanner` in CI).
+    - Create a Sonar project key.
+    - Store the scanner token in CI secrets.
+    - Provide a sample CI job that runs the scanner.
+    - If the team declines Sonar, note this in the project README and continue.
+  - If Sonar is bound to the project:
+    - Use Sonar as the primary source of actionable issues.
+    - Reference Sonar rule keys in remediation guidance.
+  - If Sonar is unavailable:
+    - Perform up to 3 troubleshooting checks:
+      1. Verify project binding and token.
+      2. Ensure SonarScanner runs in CI.
+      3. Confirm SonarLint is installed and configured.
+    - If still failing after 3 attempts:
+      - Enable SpotBugs, PMD, or Checkstyle as CI fallbacks.
+      - Open a short tracker issue documenting the blocker and next steps.
+- If the user declines static analysis tools or wants to proceed without them, continue with implementing the Best practices, bug patterns and code smell prevention guidelines outlined below.
+- Address code smells proactively during development rather than accumulating technical debt.
+- Focus on readability, maintainability, and performance when refactoring identified issues.
+- Use IDE / Code editor reported warnings and suggestions to catch common patterns early in development.
+
+## Best practices
+
+- **Records**: For classes primarily intended to store data (e.g., DTOs, immutable data structures), **Java Records should be used instead of traditional classes**.
+- **Pattern Matching**: Utilize pattern matching for `instanceof` and `switch` expression to simplify conditional logic and type casting.
+- **Type Inference**: Use `var` for local variable declarations to improve readability, but only when the type is explicitly clear from the right-hand side of the expression.
+- **Immutability**: Favor immutable objects. Make classes and fields `final` where possible. Use collections from `List.of()`/`Map.of()` for fixed data. Use `Stream.toList()` to create immutable lists.
+- **Streams and Lambdas**: Use the Streams API and lambda expressions for collection processing. Employ method references (e.g., `stream.map(Foo::toBar)`).
+- **Null Handling**: Avoid returning or accepting `null`. Use `Optional<T>` for possibly-absent values and `Objects` utility methods like `equals()` and `requireNonNull()`.
+
+### Naming Conventions
+
+- Follow Google's Java style guide:
+  - `UpperCamelCase` for class and interface names.
+  - `lowerCamelCase` for method and variable names.
+  - `UPPER_SNAKE_CASE` for constants.
+  - `lowercase` for package names.
+- Use nouns for classes (`UserService`) and verbs for methods (`getUserById`).
+- Avoid abbreviations and Hungarian notation.
+
+### Common Bug Patterns
+
+Below are concise, human-readable rules you can apply regardless of which static analysis tool you use. If you run Sonar/SonarLint, the IDE will show the matching rule and location — direct Sonar connections are preferred and should override this ruleset.
+
+- Resource management — Always close resources (files, sockets, streams). Use try-with-resources where possible so resources are closed automatically.
+- Equality checks — Compare object equality with `.equals()` or `Objects.equals(...)` rather than `==` for non-primitives; this avoids reference-equality bugs.
+- Redundant casts — Remove unnecessary casts; prefer correct generic typing and let the compiler infer types where possible.
+- Reachable conditions — Avoid conditional expressions that are always true or false; they indicate bugs or dead code and should be corrected.
+
+For contributors who _do_ use Sonar or SonarLint: the IDE/scan will show the specific rule key (for example, S2095 for resource leaks) and the affected file/line. Use that information to navigate to the exact location, then apply the recommended remediation.
+
+### Common Code Smells
+
+These patterns are phrased for humans; they map cleanly to checks in Sonar, SpotBugs, PMD, or Checkstyle but do not require those tools to be useful.
+
+- Parameter count — Keep method parameter lists short. If a method needs many params, consider grouping into a value object or using the builder pattern.
+- Method size — Keep methods focused and small. Extract helper methods to improve readability and testability.
+- Cognitive complexity — Reduce nested conditionals and heavy branching by extracting methods, using polymorphism, or applying the Strategy pattern.
+- Duplicated literals — Extract repeated strings and numbers into named constants or enums to reduce errors and ease changes.
+- Dead code — Remove unused variables and assignments. They confuse readers and can hide bugs.
+- Magic numbers — Replace numeric literals with named constants that explain intent (e.g., MAX_RETRIES).
+
+If you run a static analyzer like Sonar or SonarLint — direct Sonar connections are preferred and should override this ruleset. Sonar rule keys are useful for automation and suppression, but they are not required in day-to-day developer guidance.
+
+## Build and Verification
+
+- After adding or modifying code, verify the project continues to build successfully.
+- If the project uses Maven, run `mvn clean install`.
+- If the project uses Gradle, run `./gradlew build` (or `gradlew.bat build` on Windows).
+- Ensure all tests pass as part of the build.
+
+# Code Style Guide - Creedengo
+
+- [Code Style Guide - Creedengo](#code-style-guide---creedengo)
+  - [Introduction](#introduction)
+  - [Source File Basics](#source-file-basics)
+    - [File encoding: UTF-8](#file-encoding-utf-8)
+    - [Indentation](#indentation)
+  - [Source file structure](#source-file-structure)
+    - [Import statements](#import-statements)
+    - [Java source file organization](#java-source-file-organization)
+  - [Formatting](#formatting)
+    - [Braces](#braces)
+      - [Block-like constructs: K\&R style](#block-like-constructs-kr-style)
+    - [Line wrapping](#line-wrapping)
+    - [Blank Lines](#blank-lines)
+  - [Class declaration](#class-declaration)
+  - [Naming](#naming)
+    - [Constant names](#constant-names)
+    - [Variable names](#variable-names)
+  - [Programming Practices](#programming-practices)
+    - [File history](#file-history)
+    - [Organization of setter methods](#organization-of-setter-methods)
+    - [Ternary Operator](#ternary-operator)
+    - [Null Checks](#null-checks)
+    - [Use of @Override](#use-of-override)
+    - [Utility classes](#utility-classes)
+    - [Field and method references](#field-and-method-references)
+    - [Local variable type inference](#local-variable-type-inference)
+    - [Some rules from experience](#some-rules-from-experience)
+      - [Protections against ClassCast exceptions](#protections-against-classcast-exceptions)
+  - [Javadoc](#javadoc)
+    - [Javadoc formatting](#javadoc-formatting)
+  - [Tests](#tests)
+    - [Testing Framework](#testing-framework)
+    - [Naming](#naming-1)
+    - [Assertions](#assertions)
+    - [Mocking](#mocking)
+    - [Some rules from experience](#some-rules-from-experience-1)
+      - [Unit tests](#unit-tests)
+
+## Introduction
+
+This document defines the coding standards for source files in the plugin. It is primarily intended for the plugin team but can be used as a reference by contributors.
+
+The structure of this document is based on the [Google Java Style](https://google.github.io/styleguide/javaguide.html) reference and [Springframework Code Style](https://github.com/spring-projects/spring-framework/wiki/Code-Style) and is a _work in progress_.
+
+## Source File Basics
+
+### File encoding: UTF-8
+
+Source files must be encoded using `UTF-8`.
+
+### Indentation
+
+> In Progresss
+
+## Source file structure
+
+A source file consists of the following, in this exact order:
+
+- Package statement
+- Import statements
+- Exactly one top-level class
+
+Exactly one blank line separates each of the above sections.
+
+### Import statements
+
+> In Progresss
+
+### Java source file organization
+
+The following governs how the elements of a source file are organized:
+
+1. static fields
+1. normal fields
+1. constructors
+1. (private) methods called from constructors
+1. static factory methods
+1. JavaBean properties (i.e., getters and setters)
+1. method implementations coming from interfaces
+1. private or protected templates that get called from method implementations coming from interfaces
+1. other methods
+1. `equals`, `hashCode`, and `toString`
+
+Note that private or protected methods called from method implementations should be placed immediately below the methods where they're used. In other words if there 3 interface method implementations with 3 private methods (one used from each), then the order of methods should include 1 interface and 1 private method in sequence, not 3 interface and then 3 private methods at the bottom.
+
+Above all, the organization of the code should feel _natural_.
+
+## Formatting
+
+### Braces
+
+#### Block-like constructs: K&R style
+
+Braces mostly follow the _Kernighan and Ritchie style_ (a.k.a., "Egyptian brackets") for nonempty blocks and block-like constructs:
+
+- No line break before the opening brace but prefixed by a single space
+- Line break after the opening brace
+- Line break before the closing brace
+- Line break after the closing brace if that brace terminates a statement or the body of a method, constructor, or named class
+- Line break before else, catch and finally statements
+
+Example:
+
+```java
+return new MyClass() {
+  @Override
+  public void method() {
+    if (condition()) {
+      something();
+    }
+    else {
+      try {
+        alternative();
+      }
+      catch (ProblemException ex) {
+        recover();
+      }
+    }
+  }
+};
+```
+
+### Line wrapping
+
+90 characters is the _preferred_ line length we aim for. In some cases the preferred length can be achieved by refactoring code slightly. In other cases it's just not possible.
+
+90 is not a hard limit. Lines between 90-105 are perfectly acceptable in many cases where it aids readability and where wrapping has the opposite effect of reducing readability. This is a judgement call and it's also important to seek consistency. Many times you can learn by looking how specific situations are handled in other parts of the code.
+
+Lines between 105-120 are allowed but discouraged and should be few.
+
+No lines should exceed 120 characters.
+
+The one big exception to the above line wrapping rules is Javadoc where we aim to wrap around 80 characters for maximum readability in all kinds of contexts, e.g. reading on Github, on your phone, etc.
+
+When wrapping a lengthy expression, 90 characters is the length at which we aim to wrap. Put the separator symbols at the end of the line rather on the next line (comma separated arguments, etc). For instance:
+
+```java
+if (thisLengthyMethodCall(param1, param2) && anotherCheck() && yetAnotherCheck()) {
+  // ....
+}
+```
+
+### Blank Lines
+
+Add two blank lines before the following elements:
+
+- `static {}` block
+- Fields
+- Constructors
+- Inner classes
+
+Add one blank line after a method signature that is multiline, i.e.
+
+```java
+@Override
+protected Object invoke(FooBarOperationContext context, AnotherSuperLongName name) {
+  // code here
+}
+```
+
+For inner-classes, extra blank lines around fields and constructors are typically not
+added as the inner class is already separated by 2 lines, unless the inner class is
+more substantial in which case the 2 extra lines could still help with readability.
+
+## Class declaration
+
+Try as much as possible to put the `implements`, `extends` section of a class declaration on the same line as the class itself.
+
+Order the classes so that the most important comes first.
+
+## Naming
+
+### Constant names
+
+Constant names use `CONSTANT_CASE`: all uppercase letters, with words separated by underscores.
+
+Every constant is a `static final` field, but not all `static final` fields are constants. Constant case should therefore be chosen only if the field **is really** a constant.
+
+Example:
+
+```java
+// Constants
+private static final Object NULL_HOLDER = new NullHolder();
+public static final int DEFAULT_PORT = -1;
+
+// Not constants
+private static final ThreadLocal<Executor> executorHolder = new ThreadLocal<Executor>();
+private static final Set<String> internalAnnotationAttributes = new HashSet<String>();
+```
+
+### Variable names
+
+Avoid using single characters as variable names. For instance prefer `Method method` to `Method m`.
+
+## Programming Practices
+
+### File history
+
+- A file should look like it was crafted by a single author, not like a history of changes
+- Don't artificially spread things out that belong together
+
+### Organization of setter methods
+
+Choose wisely where to add a new setter method; it should not be simply added at the end of the list. Perhaps the setter is related to another setter or relates to a group. In that case it should be placed near related methods.
+
+- Setter order should reflect order of importance, not historical order
+- Ordering of _fields_ and _setters_ should be **consistent**
+
+### Ternary Operator
+
+Wrap the ternary operator within parentheses, i.e. `return (foo != null ? foo : "default");`
+
+Also make sure that the _not null_ condition comes first.
+
+### Null Checks
+
+Use the `org.springframework.util.Assert.notNull` static method to check that a method argument is not `null`. Format the exception message so that the name of the parameter comes first with its first character capitalized, followed by "_must not be null_". For instance
+
+```java
+public void handle(Event event) {
+    Assert.notNull(event, "Event must not be null");
+    //...
+}
+```
+
+### Use of @Override
+
+Always add `@Override` on methods overriding or implementing a method declared in a super type.
+
+### Utility classes
+
+A class that is only a collection of static utility methods must be named with a `Utils` suffix, must have a `private` default constructor, and must be `abstract`. Making the class `abstract` and providing a `private` _default_ constructor prevent anyone from instantiating it. For example:
+
+```java
+public abstract MyUtils {
+
+    private MyUtils() {
+        /* prevent instantiation */
+    }
+
+    // static utility methods
+}
+```
+
+### Field and method references
+
+A field of a class should _always_ be referenced using `this`. A method of class, however, should never be referenced using `this`.
+
+### Local variable type inference
+
+The use of `var` for variable declarations (_local variable type inference_) is not permitted. Instead, declare variables using the concrete type or interface (where applicable).
+
+### Some rules from experience
+
+#### Protections against ClassCast exceptions
+
+From experience with issue [#42](https://github.com/green-code-initiative/creedengo-rules-specifications/issues/42), when an exception occurs during Sonar analysis with maven command, the consequence is a crash. If this phase is launched in a CI/CD pipeline, this crash will block the pipeline. Thus, our plugins will be deleted until next corrections.
+
+Please, make a maximum of controls in the code to avoid ClassCast exceptions and thus, avoid uninstalling our plugin from SonarQube.
+
+## Javadoc
+
+### Javadoc formatting
+
+The following template summarizes a typical use for the Javadoc of a method.
+
+```java
+/**
+ * Parse the specified {@link Element} and register the resulting
+ * {@link BeanDefinition BeanDefinition(s)}.
+ * <p>Implementations must return the primary {@link BeanDefinition} that results
+ * from the parsing if they will ever be used in a nested fashion (for example as
+ * an inner tag in a {@code <property/>} tag). Implementations may return
+ * {@code null} if they will <strong>not</strong> be used in a nested fashion.
+ * @param element the element that is to be parsed into one or more {@link BeanDefinition BeanDefinitions}
+ * @param parserContext the object encapsulating the current state of the parsing process;
+ * provides access to a {@link org.springframework.beans.factory.support.BeanDefinitionRegistry}
+ * @return the primary {@link BeanDefinition}
+ */
+BeanDefinition parse(Element element, ParserContext parserContext);
+```
+
+In particular, please note:
+
+- Use an imperative style (i.e. _Return_ and not _Returns_) for the first sentence.
+- No blank lines between the description and the parameter descriptions.
+- If the description is defined with multiple paragraphs, start each of them with `<p>`.
+- If a parameter description needs to be wrapped, do not indent subsequent lines (see `parserContext`).
+
+The Javadoc of a class has some extra rules that are illustrated by the sample below:
+
+```java
+/*
+ * Interface used by the {@link DefaultBeanDefinitionDocumentReader} to handle custom,
+ * top-level (directly under {@code <beans/>}) tags.
+ *
+ * <p>Implementations are free to turn the metadata in the custom tag into as many
+ * {@link BeanDefinition BeanDefinitions} as required.
+ *
+ * <p>The parser locates a {@link BeanDefinitionParser} from the associated
+ * {@link NamespaceHandler} for the namespace in which the custom tag resides.
+ *
+ * @author Rob Harrop
+ * @since 2.0
+ * @see NamespaceHandler
+ * @see AbstractBeanDefinitionParser
+ */
+```
+
+- The order of tags for class-level Javadoc is: `@author`, `@since`, `@param`, `@see`, `@deprecated`.
+- The order of tags for method-level Javadoc is: `@param`, `@return`, `@throws`, `@since`, `@see`, `@deprecated`.
+- In contrast to method-level Javadoc, the paragraphs of a class description _are_ separated by blank lines.
+
+The following are additional general rules to apply when writing Javadoc:
+
+- Use `{@code}` to wrap code statements or values such as `null`.
+- If a type is only referenced by a `{@link}` element, use the fully qualified name in order to avoid an unnecessary `import` declaration.
+
+## Tests
+
+### Testing Framework
+
+Tests must be written using JUnit Jupiter (a.k.a., JUnit 5).
+
+The only exceptions to the above rule are test classes in the `spring-test` module that specifically test Spring's integration with JUnit 4 and TestNG.
+
+### Naming
+
+Each test class name must end with a `Tests` suffix.
+
+### Assertions
+
+Use AssertJ for assertions.
+
+### Mocking
+
+Use the BDD Mockito support.
+
+### Some rules from experience
+
+#### Unit tests
+
+Unit test are mandatory. If you can, use Test Driven Development method to write your tests.
+Check coverage of your tests with SoanrQube integration of our code.
diff --git a/apps/confluence-plugin/LICENSE b/apps/confluence-plugin/LICENSE
new file mode 100644
index 0000000..20d40b6
--- /dev/null
+++ b/apps/confluence-plugin/LICENSE
@@ -0,0 +1,674 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 3, 29 June 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU General Public License is a free, copyleft license for
+software and other kinds of works.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+the GNU General Public License is intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.  We, the Free Software Foundation, use the
+GNU General Public License for most of our software; it applies also to
+any other work released this way by its authors.  You can apply it to
+your programs, too.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  To protect your rights, we need to prevent others from denying you
+these rights or asking you to surrender the rights.  Therefore, you have
+certain responsibilities if you distribute copies of the software, or if
+you modify it: responsibilities to respect the freedom of others.
+
+  For example, if you distribute copies of such a program, whether
+gratis or for a fee, you must pass on to the recipients the same
+freedoms that you received.  You must make sure that they, too, receive
+or can get the source code.  And you must show them these terms so they
+know their rights.
+
+  Developers that use the GNU GPL protect your rights with two steps:
+(1) assert copyright on the software, and (2) offer you this License
+giving you legal permission to copy, distribute and/or modify it.
+
+  For the developers' and authors' protection, the GPL clearly explains
+that there is no warranty for this free software.  For both users' and
+authors' sake, the GPL requires that modified versions be marked as
+changed, so that their problems will not be attributed erroneously to
+authors of previous versions.
+
+  Some devices are designed to deny users access to install or run
+modified versions of the software inside them, although the manufacturer
+can do so.  This is fundamentally incompatible with the aim of
+protecting users' freedom to change the software.  The systematic
+pattern of such abuse occurs in the area of products for individuals to
+use, which is precisely where it is most unacceptable.  Therefore, we
+have designed this version of the GPL to prohibit the practice for those
+products.  If such problems arise substantially in other domains, we
+stand ready to extend this provision to those domains in future versions
+of the GPL, as needed to protect the freedom of users.
+
+  Finally, every program is threatened constantly by software patents.
+States should not allow patents to restrict development and use of
+software on general-purpose computers, but in those that do, we wish to
+avoid the special danger that patents applied to a free program could
+make it effectively proprietary.  To prevent this, the GPL assures that
+patents cannot be used to render the program non-free.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Use with the GNU Affero General Public License.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU Affero General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the special requirements of the GNU Affero General Public License,
+section 13, concerning interaction through a network will apply to the
+combination as such.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU General Public License from time to time.  Such new versions will
+be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If the program does terminal interaction, make it output a short
+notice like this when it starts in an interactive mode:
+
+    <program>  Copyright (C) <year>  <name of author>
+    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
+    This is free software, and you are welcome to redistribute it
+    under certain conditions; type `show c' for details.
+
+The hypothetical commands `show w' and `show c' should show the appropriate
+parts of the General Public License.  Of course, your program's commands
+might be different; for a GUI interface, you would use an "about box".
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU GPL, see
+<http://www.gnu.org/licenses/>.
+
+  The GNU General Public License does not permit incorporating your program
+into proprietary programs.  If your program is a subroutine library, you
+may consider it more useful to permit linking proprietary applications with
+the library.  If this is what you want to do, use the GNU Lesser General
+Public License instead of this License.  But first, please read
+<http://www.gnu.org/philosophy/why-not-lgpl.html>.
\ No newline at end of file
diff --git a/apps/confluence-plugin/README b/apps/confluence-plugin/README
new file mode 100644
index 0000000..f46276e
--- /dev/null
+++ b/apps/confluence-plugin/README
@@ -0,0 +1,11 @@
+You have successfully created an Atlassian Plugin!
+
+Here are the SDK commands you'll use immediately:
+
+* atlas-run   -- installs this plugin into the product and starts it on localhost
+* atlas-debug -- same as atlas-run, but allows a debugger to attach at port 5005
+* atlas-help  -- prints description for all commands in the SDK
+
+Full documentation is always available at:
+
+https://developer.atlassian.com/display/DOCS/Introduction+to+the+Atlassian+Plugin+SDK
diff --git a/apps/confluence-plugin/capture-sonar-fixtures.py b/apps/confluence-plugin/capture-sonar-fixtures.py
new file mode 100644
index 0000000..e41294d
--- /dev/null
+++ b/apps/confluence-plugin/capture-sonar-fixtures.py
@@ -0,0 +1,242 @@
+#!/usr/bin/env python3
+"""
+Capture SonarQube API responses as fixture files for MockSonarServer.
+
+Usage:
+    python3 capture-sonar-fixtures.py [--url URL] [--token TOKEN] [--project PROJECT]
+
+Environment variables (fallback if CLI args not given):
+    SONAR_URL    Base URL of SonarQube instance  (default: http://localhost:9000)
+    SONAR_TOKEN  Authentication bearer token
+    SONAR_PROJECT Project key                    (default: org.green-code-initiative:creedengo-java-plugin-test-project)
+
+Captured fixtures are written to:
+    src/test/resources/fixtures/sonar/
+"""
+
+import argparse
+import json
+import os
+import sys
+import urllib.request
+import urllib.parse
+from pathlib import Path
+
+# ---------------------------------------------------------------------------
+# Configuration
+# ---------------------------------------------------------------------------
+
+DEFAULT_URL     = "http://localhost:9000"
+DEFAULT_PROJECT = "org.green-code-initiative:creedengo-java-plugin-test-project"
+DEFAULT_BRANCH  = "main"
+OUT_DIR         = Path(__file__).parent / "src/test/resources/fixtures/sonar"
+
+# Fields to keep for each issue (verbose ones like flows/msgFormattings are dropped)
+ISSUE_FIELDS = [
+    "key", "rule", "severity", "component", "project", "line",
+    "status", "message", "effort", "debt", "tags",
+    "creationDate", "updateDate", "type", "scope",
+    "cleanCodeAttribute", "cleanCodeAttributeCategory",
+    "impacts", "issueStatus",
+]
+
+# Fields to keep for each rule (descriptionSections can be huge)
+RULE_FIELDS = [
+    "key", "repo", "name", "severity", "status",
+    "tags", "sysTags", "lang", "langName", "type",
+    "defaultRemFnBaseEffort", "remFnBaseEffort", "scope",
+    "cleanCodeAttribute", "cleanCodeAttributeCategory", "impacts",
+]
+
+# ---------------------------------------------------------------------------
+# HTTP helpers
+# ---------------------------------------------------------------------------
+
+def fetch(base_url: str, token: str, route: str, params: dict) -> dict:
+    query = urllib.parse.urlencode(params)
+    url = f"{base_url.rstrip('/')}/{route}?{query}"
+    req = urllib.request.Request(url, headers={"Authorization": f"Bearer {token}"})
+    try:
+        with urllib.request.urlopen(req, timeout=15) as resp:
+            return json.loads(resp.read().decode())
+    except urllib.error.HTTPError as exc:
+        body = exc.read().decode()
+        print(f"  HTTP {exc.code} for {route}: {body}", file=sys.stderr)
+        raise
+
+
+def save(path: Path, data: dict) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(data, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
+    print(f"  Saved {path.relative_to(Path.cwd()) if path.is_relative_to(Path.cwd()) else path}")
+
+
+# ---------------------------------------------------------------------------
+# Capture functions
+# ---------------------------------------------------------------------------
+
+def capture_issues(base_url, token, project, branch, out_dir: Path) -> None:
+    print("→ api/issues/search (tags=sustainability, facets=severities,types) …")
+    data = fetch(base_url, token, "api/issues/search", {
+        "componentKeys": project,
+        "branch":        branch,
+        "resolved":      "false",
+        "tags":          "sustainability",
+        "facets":        "severities,types",
+        "ps":            "500",
+    })
+
+    # Keep 3 issues with distinct rules
+    seen_rules: set = set()
+    kept = []
+    for issue in data.get("issues", []):
+        rule = issue.get("rule", "")
+        if rule not in seen_rules:
+            seen_rules.add(rule)
+            kept.append({k: issue[k] for k in ISSUE_FIELDS if k in issue})
+        if len(kept) == 3:
+            break
+
+    # Keep only TRK/FIL components
+    components = [
+        c for c in data.get("components", [])
+        if c.get("qualifier") in ("TRK", "FIL")
+    ][:2]
+
+    out = {
+        "total":      data["total"],
+        "p":          1,
+        "ps":         100,
+        "paging":     {"pageIndex": 1, "pageSize": 100, "total": data["total"]},
+        "effortTotal": data.get("effortTotal"),
+        "issues":     kept,
+        "components": components,
+        "facets":     data.get("facets", []),
+    }
+    save(out_dir / "issues-search.json", out)
+
+
+def capture_measures(base_url, token, project, branch, out_dir: Path) -> None:
+    print("→ api/measures/component …")
+    metrics = ",".join([
+        "ncloc", "coverage", "bugs", "vulnerabilities", "code_smells",
+        "sqale_index", "alert_status", "reliability_rating",
+        "security_rating", "sqale_rating",
+    ])
+    data = fetch(base_url, token, "api/measures/component", {
+        "component":  project,
+        "branch":     branch,
+        "metricKeys": metrics,
+    })
+    save(out_dir / "measures-component.json", data)
+
+
+def capture_branches(base_url, token, project, out_dir: Path) -> None:
+    print("→ api/project_branches/list …")
+    data = fetch(base_url, token, "api/project_branches/list", {"project": project})
+
+    # Augment with a synthetic non-main branch so that tests can exercise
+    # multi-branch parsing even when the captured project has only one branch.
+    has_non_main = any(not b.get("isMain", True) for b in data.get("branches", []))
+    if not has_non_main:
+        data["branches"].append({
+            "name": "develop",
+            "isMain": False,
+            "type": "BRANCH",
+            "status": {"qualityGateStatus": "OK"},
+            "analysisDate": "2025-12-01T10:00:00+0100",
+            "excludedFromPurge": False,
+            "branchId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890",
+        })
+        print("  (added synthetic 'develop' branch for multi-branch test coverage)")
+
+    save(out_dir / "project-branches.json", data)
+
+
+def capture_rules(base_url, token, project, branch, out_dir: Path) -> None:
+    print("→ api/rules/search (tags=sustainability) …")
+    data = fetch(base_url, token, "api/rules/search", {
+        "tags":          "sustainability",
+        "componentKeys": project,
+        "branch":        branch,
+        "ps":            "10",
+    })
+
+    kept = [{k: r[k] for k in RULE_FIELDS if k in r} for r in data.get("rules", [])[:5]]
+    out = {
+        "total": data["total"],
+        "p":     1,
+        "ps":    10,
+        "rules": kept,
+    }
+    save(out_dir / "rules-search.json", out)
+
+    # Capture details for the first rule (rules/show)
+    if kept:
+        first_key = kept[0]["key"]
+        print(f"→ api/rules/show (rule={first_key}) …")
+        detail_data = fetch(base_url, token, "api/rules/show", {"key": first_key})
+        rule = detail_data.get("rule", {})
+
+        # Keep only a subset of fields for the show fixture
+        show_fields = RULE_FIELDS + ["htmlDesc", "mdDesc", "descriptionSections"]
+        show_rule = {k: rule[k] for k in show_fields if k in rule}
+
+        # Build a minimal htmlDesc from descriptionSections if htmlDesc is absent
+        if "htmlDesc" not in show_rule:
+            sections = rule.get("descriptionSections", [])
+            root_cause = next((s["content"] for s in sections if s.get("key") == "root_cause"), None)
+            show_rule["htmlDesc"] = root_cause or ""
+
+        save(out_dir / "rules-show.json", {"rule": show_rule})
+
+
+def capture_pull_requests(base_url, token, project, out_dir: Path) -> None:
+    print("→ api/project_pull_requests/list …")
+    try:
+        data = fetch(base_url, token, "api/project_pull_requests/list", {"project": project})
+        if "errors" in data:
+            print(f"  Endpoint not available ({data['errors'][0]['msg']}); keeping existing fixture.")
+            return
+        save(out_dir / "project-pull-requests.json", data)
+    except Exception as exc:
+        print(f"  Skipped pull-requests (not available): {exc}")
+
+
+# ---------------------------------------------------------------------------
+# Entry point
+# ---------------------------------------------------------------------------
+
+def parse_args():
+    parser = argparse.ArgumentParser(description=__doc__,
+                                     formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--url",     default=os.environ.get("SONAR_URL",     DEFAULT_URL))
+    parser.add_argument("--token",   default=os.environ.get("SONAR_TOKEN",   ""))
+    parser.add_argument("--project", default=os.environ.get("SONAR_PROJECT", DEFAULT_PROJECT))
+    parser.add_argument("--branch",  default=DEFAULT_BRANCH)
+    return parser.parse_args()
+
+
+def main():
+    args = parse_args()
+
+    if not args.token:
+        print("Error: Sonar token is required (--token or SONAR_TOKEN env var).", file=sys.stderr)
+        sys.exit(1)
+
+    print(f"Capturing Sonar API responses from {args.url}")
+    print(f"  Project : {args.project}")
+    print(f"  Branch  : {args.branch}")
+    print(f"  Output  : {OUT_DIR}\n")
+
+    capture_issues(args.url, args.token, args.project, args.branch, OUT_DIR)
+    capture_measures(args.url, args.token, args.project, args.branch, OUT_DIR)
+    capture_branches(args.url, args.token, args.project, OUT_DIR)
+    capture_rules(args.url, args.token, args.project, args.branch, OUT_DIR)
+    capture_pull_requests(args.url, args.token, args.project, OUT_DIR)
+
+    print("\nDone. Commit the updated fixture files to version the snapshots.")
+
+
+if __name__ == "__main__":
+    main()
diff --git a/apps/confluence-plugin/package.json b/apps/confluence-plugin/package.json
new file mode 100644
index 0000000..890d7fc
--- /dev/null
+++ b/apps/confluence-plugin/package.json
@@ -0,0 +1,5 @@
+{
+  "name": "creedengo-confluence-plugin",
+  "private": true,
+  "version": "1.0.0-SNAPSHOT"
+}
\ No newline at end of file
diff --git a/apps/confluence-plugin/pom.xml b/apps/confluence-plugin/pom.xml
new file mode 100644
index 0000000..5257c78
--- /dev/null
+++ b/apps/confluence-plugin/pom.xml
@@ -0,0 +1,141 @@
+<?xml version="1.0" encoding="UTF-8"?>
+
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+
+    <modelVersion>4.0.0</modelVersion>
+    <groupId>org.green-code-initiative</groupId>
+    <artifactId>creedengo-confluence-plugin</artifactId>
+    <version>1.0.0-SNAPSHOT</version>
+
+    <organization>
+        <name>green-code-initiative</name>
+        <url>https://green-code-initiative.org/</url>
+    </organization>
+
+    <name>creedengo-confluence-plugin</name>
+    <description>This is the creedengo-confluence-plugin plugin for Atlassian Confluence.</description>
+    <packaging>atlassian-plugin</packaging>
+
+    <dependencies>
+        <dependency>
+            <groupId>junit</groupId>
+            <artifactId>junit</artifactId>
+            <version>4.10</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.atlassian.confluence</groupId>
+            <artifactId>confluence</artifactId>
+            <version>${confluence.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.atlassian.plugin</groupId>
+            <artifactId>atlassian-spring-scanner-annotation</artifactId>
+            <version>${atlassian.spring.scanner.version}</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>javax.inject</groupId>
+            <artifactId>javax.inject</artifactId>
+            <version>1</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <!-- WIRED TEST RUNNER DEPENDENCIES -->
+        <dependency>
+            <groupId>com.atlassian.plugins</groupId>
+            <artifactId>atlassian-plugins-osgi-testrunner</artifactId>
+            <version>${plugin.testrunner.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>javax.ws.rs</groupId>
+            <artifactId>jsr311-api</artifactId>
+            <version>1.1.1</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <!-- MOCKITO FOR UNIT TESTS -->
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-core</artifactId>
+            <version>2.28.1</version>
+                <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <plugin>
+                <groupId>com.atlassian.maven.plugins</groupId>
+                <artifactId>confluence-maven-plugin</artifactId>
+                <version>${amps.version}</version>
+                <extensions>true</extensions>
+                <configuration>
+                    <productVersion>${confluence.version}</productVersion>
+                    <productDataVersion>${confluence.data.version}</productDataVersion>
+                    <enableQuickReload>true</enableQuickReload>
+
+                    <!-- See here for an explanation of default instructions: -->
+                    <!-- https://developer.atlassian.com/docs/advanced-topics/configuration-of-instructions-in-atlassian-plugins -->
+                    <instructions>
+                        <Atlassian-Plugin-Key>${atlassian.plugin.key}</Atlassian-Plugin-Key>
+
+                        <!-- Add package to export here -->
+                        <Export-Package>
+                            org.greencodeinitiative.creedengo.confluence.plugin.api,
+                        </Export-Package>
+
+                        <!-- Add package import here -->
+                        <Import-Package>
+                            org.springframework.osgi.*;resolution:="optional",
+                            org.eclipse.gemini.blueprint.*;resolution:="optional",
+                            *
+                        </Import-Package>
+
+                        <!-- Ensure plugin is spring powered -->
+                        <Spring-Context>*</Spring-Context>
+                    </instructions>
+
+                </configuration>
+            </plugin>
+            <plugin>
+                <groupId>com.atlassian.plugin</groupId>
+                <artifactId>atlassian-spring-scanner-maven-plugin</artifactId>
+                <version>${atlassian.spring.scanner.version}</version>
+                <executions>
+                    <execution>
+                        <goals>
+                            <goal>atlassian-spring-scanner</goal>
+                        </goals>
+                        <!-- process-classes seems to be skipped if you are using scala
+                        so perhaps use prepare-package -->
+                        <phase>process-classes</phase> 
+                    </execution>
+                </executions>
+                <configuration>
+                    <!-- Enable this to get build-time logging of annotations atlassian-spring-scanner-maven-plugin has noticed -->
+                    <verbose>true</verbose>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+    <properties>
+        
+        <confluence.version>8.5.4</confluence.version>
+        <confluence.data.version>8.5.4</confluence.data.version>
+        <amps.version>9.1.1</amps.version>
+        <plugin.testrunner.version>2.0.9</plugin.testrunner.version>
+        <atlassian.spring.scanner.version>2.2.4</atlassian.spring.scanner.version>
+        <!-- This property ensures consistency between the key in atlassian-plugin.xml and the OSGi bundle's key. -->
+        <atlassian.plugin.key>${project.groupId}.${project.artifactId}</atlassian.plugin.key>
+        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
+        <maven.compiler.source>1.8</maven.compiler.source>
+        <maven.compiler.target>1.8</maven.compiler.target>
+    </properties>
+
+</project>
diff --git a/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/api/MyPluginComponent.java b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/api/MyPluginComponent.java
new file mode 100644
index 0000000..3012f03
--- /dev/null
+++ b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/api/MyPluginComponent.java
@@ -0,0 +1,5 @@
+package org.greencodeinitiative.creedengo.confluence.plugin.api;
+
+public interface MyPluginComponent {
+    String getName();
+}
\ No newline at end of file
diff --git a/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/impl/MyPluginComponentImpl.java b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/impl/MyPluginComponentImpl.java
new file mode 100644
index 0000000..6be8430
--- /dev/null
+++ b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/impl/MyPluginComponentImpl.java
@@ -0,0 +1,31 @@
+package org.greencodeinitiative.creedengo.confluence.plugin.impl;
+
+import com.atlassian.plugin.spring.scanner.annotation.export.ExportAsService;
+import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport;
+import com.atlassian.sal.api.ApplicationProperties;
+import org.greencodeinitiative.creedengo.confluence.plugin.api.MyPluginComponent;
+
+import javax.inject.Inject;
+import javax.inject.Named;
+
+@ExportAsService ({MyPluginComponent.class})
+@Named ("myPluginComponent")
+public class MyPluginComponentImpl implements MyPluginComponent
+{
+        @ComponentImport
+        private final ApplicationProperties applicationProperties;
+
+        @Inject
+    
+    public MyPluginComponentImpl(final ApplicationProperties applicationProperties) {
+        this.applicationProperties = applicationProperties;
+    }
+
+    public String getName() {
+        if (null != applicationProperties) {
+            return "myComponent:" + applicationProperties.getDisplayName();
+        }
+
+        return "myComponent";
+    }
+}
\ No newline at end of file
diff --git a/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/macro/Dashboard.java b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/macro/Dashboard.java
new file mode 100644
index 0000000..d905db4
--- /dev/null
+++ b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/macro/Dashboard.java
@@ -0,0 +1,109 @@
+/*
+ * Creedengo Dashboard plugin - Provides dashboard to monitor and help reduce the environmental footprint of your programs
+ * Copyright © 2025 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.greencodeinitiative.creedengo.confluence.plugin.macro;
+
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import com.atlassian.confluence.content.render.xhtml.ConversionContext;
+import com.atlassian.confluence.macro.Macro;
+import com.atlassian.confluence.macro.MacroExecutionException;
+import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport;
+import com.atlassian.webresource.api.assembler.PageBuilderService;
+
+public class Dashboard implements Macro {
+
+    private final PageBuilderService pageBuilderService;
+    private static final Logger log = LoggerFactory.getLogger(Dashboard.class);
+
+    @Autowired
+    public Dashboard(@ComponentImport PageBuilderService pageBuilderService) {
+        this.pageBuilderService = pageBuilderService;
+    }
+
+    @Override
+    public String execute(Map<String, String> map, String s, ConversionContext conversionContext) throws MacroExecutionException {
+        MacroHelper.requireWebResources(pageBuilderService);
+        log.info("creedengo : Executing Dashboard macro with parameters: {}", map.toString());
+
+        String sonarqubeUrl = map.get("sonarqube_url");
+        String sonarqubeToken = map.get("sonarqube_token");
+        String projectKey = map.get("project_key");
+        String branch = map.getOrDefault("branch", "main");
+
+        StringBuilder output = new StringBuilder();
+        if (sonarqubeUrl != null) {
+            if (!MacroHelper.isValidUrl(sonarqubeUrl)) {
+                log.warn("creedengo : Invalid SonarQube URL format: {}", sonarqubeUrl);
+                output.append("<div class=\"aui-message aui-message-error\">")
+                      .append("<p><strong>Erreur :</strong> L'URL SonarQube fournie est invalide : ")
+                      .append(MacroHelper.escapeHtml(sonarqubeUrl))
+                      .append("</p>")
+                      .append("<p>Format attendu : <code>https://sonar.example.com</code></p>")
+                      .append("</div>");
+            } else {
+                String serverStatus = MacroHelper.verifySonarServer(sonarqubeUrl, sonarqubeToken);
+                if (serverStatus != null) {
+                    log.warn("creedengo : SonarQube server verification failed: {}", serverStatus);
+                    output.append("<div class=\"aui-message aui-message-warning\">")
+                          .append("<p><strong>Attention :</strong> Impossible de joindre le serveur SonarQube.</p>")
+                          .append("<p>").append(MacroHelper.escapeHtml(serverStatus)).append("</p>")
+                          .append("</div>");
+                } else {
+                    output.append("<div class=\"creedengo-dashboard\">");
+                    
+                    // Retrieve project name from SonarQube
+                    String projectName = projectKey; // Default to key
+                    try {
+                        org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarService sonarService = 
+                            new org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarService(sonarqubeUrl, sonarqubeToken);
+                        projectName = sonarService.projectInfo().getProjectName(projectKey);
+                    } catch (Exception e) {
+                        log.warn("creedengo : Failed to retrieve project name from SonarQube, using project key instead: {}", projectKey, e);
+                    }
+                    
+                    output.append("<h1>Creedengo Dashboard of project ").append(MacroHelper.escapeHtml(projectName)).append("!</h1>");
+                    output.append("<div class=\"creedengo-dashboard-columns\">");
+                    
+                    output.append("<div class=\"creedengo-dashboard-column\">");
+                    EcoScore.appendScoreSection(output, sonarqubeUrl, sonarqubeToken, projectKey, branch, false);
+                    output.append("</div>");
+                    
+                    output.append("<div class=\"creedengo-dashboard-column\">");
+                    PriorityRulesMacro.appendPriorityRulesSection(output, sonarqubeUrl, sonarqubeToken, projectKey, branch, false);
+                    output.append("</div>");
+                    
+                    output.append("</div>");
+                    output.append("</div>");
+                }
+            }
+        } else {
+            output.append("<h1>Dashboard Creedengo! empty sonarqube_url</h1>");
+        }
+        return output.toString();
+    }
+
+    @Override
+    public Macro.BodyType getBodyType() { return Macro.BodyType.NONE; }
+
+    @Override
+    public Macro.OutputType getOutputType() { return Macro.OutputType.BLOCK; }
+}
diff --git a/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/macro/EcoScore.java b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/macro/EcoScore.java
new file mode 100644
index 0000000..0b1b6fb
--- /dev/null
+++ b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/macro/EcoScore.java
@@ -0,0 +1,141 @@
+/*
+ * Creedengo Dashboard plugin - Provides dashboard to monitor and help reduce the environmental footprint of your programs
+ * Copyright © 2025 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.greencodeinitiative.creedengo.confluence.plugin.macro;
+
+import java.util.Map;
+
+import org.greencodeinitiative.creedengo.confluence.plugin.service.ScoreService;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarApiException;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import com.atlassian.confluence.content.render.xhtml.ConversionContext;
+import com.atlassian.confluence.macro.Macro;
+import com.atlassian.confluence.macro.MacroExecutionException;
+import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport;
+import com.atlassian.webresource.api.assembler.PageBuilderService;
+
+public class EcoScore implements Macro {
+
+    private final PageBuilderService pageBuilderService;
+    private static final Logger log = LoggerFactory.getLogger(EcoScore.class);
+    private static final String[] SCORE_LETTERS = {"A", "B", "C", "D", "E"};
+
+    @Autowired
+    public EcoScore(@ComponentImport PageBuilderService pageBuilderService) {
+        this.pageBuilderService = pageBuilderService;
+    }
+
+    @Override
+    public String execute(Map<String, String> map, String s, ConversionContext conversionContext) throws MacroExecutionException {
+        MacroHelper.requireWebResources(pageBuilderService);
+        log.info("creedengo : Executing EcoScore macro with parameters: {}", map.toString());
+
+        String sonarqubeUrl = map.get("sonarqube_url");
+        String sonarqubeToken = map.get("sonarqube_token");
+        String projectKey = map.get("project_key");
+        String branch = map.getOrDefault("branch", "main");
+
+        StringBuilder output = new StringBuilder();
+        if (sonarqubeUrl != null) {
+            if (!MacroHelper.isValidUrl(sonarqubeUrl)) {
+                log.warn("creedengo : Invalid SonarQube URL format: {}", sonarqubeUrl);
+                output.append("<div class=\"aui-message aui-message-error\">")
+                      .append("<p><strong>Erreur :</strong> L'URL SonarQube fournie est invalide : ")
+                      .append(MacroHelper.escapeHtml(sonarqubeUrl))
+                      .append("</p>")
+                      .append("<p>Format attendu : <code>https://sonar.example.com</code></p>")
+                      .append("</div>");
+            } else {
+                String serverStatus = MacroHelper.verifySonarServer(sonarqubeUrl, sonarqubeToken);
+                if (serverStatus != null) {
+                    log.warn("creedengo : SonarQube server verification failed: {}", serverStatus);
+                    output.append("<div class=\"aui-message aui-message-warning\">")
+                          .append("<p><strong>Attention :</strong> Impossible de joindre le serveur SonarQube.</p>")
+                          .append("<p>").append(MacroHelper.escapeHtml(serverStatus)).append("</p>")
+                          .append("</div>");
+                } else {
+
+                    appendScoreSection(output, sonarqubeUrl, sonarqubeToken, projectKey, branch, true);
+                }
+            }
+        } else {
+            output.append("<h1>")
+                  .append(MacroHelper.getText("ecoscore.header.emptyurl"))
+                  .append("</h1>");
+        }
+        return output.toString();
+    }
+
+    public static void appendScoreSection(StringBuilder output, String sonarqubeUrl,
+                                     String sonarqubeToken, String projectKey, String branch, boolean displayHeader) {
+        try {
+            SonarService sonarService = new SonarService(sonarqubeUrl, sonarqubeToken);
+            ScoreService scoreService = new ScoreService(sonarService);
+            String score = scoreService.calculateProjectScore(projectKey, branch);
+            ScoreService.ScoreTexts texts = ScoreService.getScoreTexts(score);
+            log.info("creedengo : Calculated score {} for project {} on branch {}", score, projectKey, branch);
+
+            output.append("<div class=\"creedengo-score-widget\">");
+            if (displayHeader) {
+                output.append("<h2>").append(MacroHelper.getText("ecoscore.header", MacroHelper.escapeHtml(projectKey))).append("</h2>");
+            }
+                                
+            output.append("<h2 class=\"creedengo-score-title\">").append(MacroHelper.getText("ecoscore.subheader")).append("</h2>")
+                .append("<div class=\"creedengo-rate-list\">");
+            for (String letter : SCORE_LETTERS) {
+                boolean isActive = letter.equals(score);
+                if (isActive) {
+                    output.append("<span class=\"creedengo-rate creedengo-rate-")
+                          .append(letter.toLowerCase())
+                          .append("\"><strong>")
+                          .append(letter)
+                          .append("</strong></span>");
+                }
+                output.append("<span class=\"creedengo-rate-item creedengo-rate-bg-")
+                      .append(letter.toLowerCase())
+                      .append("\">")
+                      .append(letter)
+                      .append("</span>");
+            }
+            output.append("</div>");
+            if (texts != null) {
+                output.append("<div class=\"creedengo-score-texts\">")
+                      .append("<p class=\"creedengo-score-label\">").append(MacroHelper.escapeHtml(texts.getLabel())).append("</p>")
+                      .append("<p class=\"creedengo-score-desc\">").append(MacroHelper.escapeHtml(texts.getDescription())).append("</p>")
+                      .append("<p class=\"creedengo-score-tips\"><em>").append(MacroHelper.escapeHtml(texts.getTips())).append("</em></p>")
+                      .append("</div>");
+            }
+            output.append("</div>");
+        } catch (SonarApiException e) {
+            log.error("creedengo : Failed to calculate score for project {}", projectKey, e);
+            output.append("<div class=\"aui-message aui-message-warning\">")
+                  .append("<p><strong>Attention :</strong> Impossible de calculer le score Creedengo.</p>")
+                  .append("<p>").append(MacroHelper.escapeHtml(e.getMessage())).append("</p>")
+                  .append("</div>");
+        }
+    }
+
+    @Override
+    public Macro.BodyType getBodyType() { return Macro.BodyType.NONE; }
+
+    @Override
+    public Macro.OutputType getOutputType() { return Macro.OutputType.BLOCK; }
+}
diff --git a/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/macro/MacroHelper.java b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/macro/MacroHelper.java
new file mode 100644
index 0000000..4efc903
--- /dev/null
+++ b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/macro/MacroHelper.java
@@ -0,0 +1,79 @@
+
+package org.greencodeinitiative.creedengo.confluence.plugin.macro;
+
+import java.util.regex.Pattern;
+
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarApiException;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarClient;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import com.atlassian.webresource.api.assembler.PageBuilderService;
+
+public class MacroHelper {
+    private static final Logger log = LoggerFactory.getLogger(MacroHelper.class);
+    private static final Pattern URL_PATTERN = Pattern.compile(
+            "^https?://[a-zA-Z0-9]([a-zA-Z0-9\\-]*[a-zA-Z0-9])?(\\.[a-zA-Z0-9]([a-zA-Z0-9\\-]*[a-zA-Z0-9])?)*"
+            + "(:\\d{1,5})?(/[^\\s]*)?$"
+    );
+
+    public static boolean isValidUrl(String url) {
+        if (url == null || url.trim().isEmpty()) {
+            return false;
+        }
+        return URL_PATTERN.matcher(url.trim()).matches();
+    }
+
+    public static String verifySonarServer(String sonarqubeUrl, String sonarqubeToken) {
+        try {
+            SonarClient client = new SonarClient(sonarqubeUrl, sonarqubeToken);
+            String status = client.checkServerStatus();
+            if (!"UP".equals(status)) {
+                return "Le serveur SonarQube a répondu mais son statut est : " + status;
+            }
+            return null; // success
+        } catch (SonarApiException e) {
+            return "Erreur de connexion au serveur SonarQube : " + e.getMessage();
+        }
+    }
+
+    public static void requireWebResources(PageBuilderService pageBuilderService) {
+        try {
+            pageBuilderService.assembler().resources().requireWebResource("org.green-code-initiative.creedengo-confluence-plugin:creedengo-confluence-plugin-resources");
+            log.debug("creedengo : Web resources loaded successfully");
+        } catch (Exception e) {
+            log.error("creedengo : Failed to load web resources", e);
+        }
+    }
+
+    public static String escapeHtml(String value) {
+        if (value == null) {
+            return "";
+        }
+        return value.replace("&", "&amp;")
+                .replace("<", "&lt;")
+                .replace(">", "&gt;")
+                .replace("\"", "&quot;")
+                .replace("'", "&#39;");
+    }
+        /**
+     * Récupère une chaîne i18n depuis les ressources Atlassian (avec paramètres optionnels).
+     * @param key la clé i18n
+     * @param params paramètres à injecter dans la chaîne (optionnel)
+     * @return la chaîne traduite, ou la clé si non trouvée
+     */
+    public static String getText(String key, Object... params) {
+        try {
+            com.atlassian.sal.api.message.I18nResolver resolver =
+                com.atlassian.sal.api.component.ComponentLocator.getComponent(com.atlassian.sal.api.message.I18nResolver.class);
+            if (resolver != null) {
+                // Cast params to Serializable[] to match the method signature
+                return resolver.getText(key, params != null ? java.util.Arrays.copyOf(params, params.length, java.io.Serializable[].class) : null);
+            }
+        } catch (Throwable t) {
+            log.warn("Could not resolve i18n key: {}", key, t);
+        }
+        // fallback: return key
+        return key;
+    }
+}
diff --git a/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/macro/PieChartMacro.java b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/macro/PieChartMacro.java
new file mode 100644
index 0000000..36b15a7
--- /dev/null
+++ b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/macro/PieChartMacro.java
@@ -0,0 +1,227 @@
+/*
+ * Creedengo Dashboard plugin - Provides dashboard to monitor and help reduce the environmental footprint of your programs
+ * Copyright © 2025 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.greencodeinitiative.creedengo.confluence.plugin.macro;
+
+import java.util.Locale;
+import java.util.Map;
+
+import org.greencodeinitiative.creedengo.confluence.plugin.service.PieChartService;
+import org.greencodeinitiative.creedengo.confluence.plugin.service.PieChartService.PieChartData;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarApiException;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarService;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import com.atlassian.confluence.content.render.xhtml.ConversionContext;
+import com.atlassian.confluence.macro.Macro;
+import com.atlassian.confluence.macro.MacroExecutionException;
+import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport;
+import com.atlassian.webresource.api.assembler.PageBuilderService;
+
+/**
+ * Confluence macro that renders a donut (pie) chart showing open SonarQube issues
+ * filtered by a specific metric tag (e.g. CPU or RAM).
+ *
+ * <p>Each arc segment is proportional to the number of issues at that severity:</p>
+ * <ul>
+ *   <li>Yellow — minor / info</li>
+ *   <li>Orange — major</li>
+ *   <li>Red    — blocker / critical</li>
+ *   <li>Green  — remaining (no open issues)</li>
+ * </ul>
+ */
+public class PieChartMacro implements Macro {
+
+    private static final Logger log = LoggerFactory.getLogger(PieChartMacro.class);
+
+    private final PageBuilderService pageBuilderService;
+
+    @Autowired
+    public PieChartMacro(@ComponentImport PageBuilderService pageBuilderService) {
+        this.pageBuilderService = pageBuilderService;
+    }
+
+    @Override
+    public String execute(Map<String, String> map, String s, ConversionContext conversionContext)
+            throws MacroExecutionException {
+        MacroHelper.requireWebResources(pageBuilderService);
+        log.info("creedengo : Executing PieChartMacro with parameters: {}", map.toString());
+
+        String sonarqubeUrl = map.get("sonarqube_url");
+        String sonarqubeToken = map.get("sonarqube_token");
+        String projectKey = map.get("project_key");
+        String branch = map.getOrDefault("branch", "main");
+        String metricTag = map.getOrDefault("metric_tag", "cpu").toUpperCase(Locale.ROOT);
+
+        StringBuilder output = new StringBuilder();
+
+        if (sonarqubeUrl == null) {
+            output.append("<h1>")
+                  .append(MacroHelper.getText("piechart.header.emptyurl"))
+                  .append("</h1>");
+            return output.toString();
+        }
+
+        if (!MacroHelper.isValidUrl(sonarqubeUrl)) {
+            log.warn("creedengo : Invalid SonarQube URL format: {}", sonarqubeUrl);
+            output.append("<div class=\"aui-message aui-message-error\">")
+                  .append("<p><strong>Erreur :</strong> L'URL SonarQube fournie est invalide : ")
+                  .append(MacroHelper.escapeHtml(sonarqubeUrl))
+                  .append("</p>")
+                  .append("<p>Format attendu : <code>https://sonar.example.com</code></p>")
+                  .append("</div>");
+            return output.toString();
+        }
+
+        String serverStatus = MacroHelper.verifySonarServer(sonarqubeUrl, sonarqubeToken);
+        if (serverStatus != null) {
+            log.warn("creedengo : SonarQube server verification failed: {}", serverStatus);
+            output.append("<div class=\"aui-message aui-message-warning\">")
+                  .append("<p><strong>Attention :</strong> Impossible de joindre le serveur SonarQube.</p>")
+                  .append("<p>").append(MacroHelper.escapeHtml(serverStatus)).append("</p>")
+                  .append("</div>");
+            return output.toString();
+        }
+
+        appendPieChartSection(output, sonarqubeUrl, sonarqubeToken, projectKey, branch, metricTag, true);
+        return output.toString();
+    }
+
+    /**
+     * Build and append the full PieChart HTML section to {@code output}.
+     *
+     * @param output        the string builder to append to
+     * @param sonarqubeUrl  the SonarQube server base URL
+     * @param sonarqubeToken the authentication token
+     * @param projectKey    the SonarQube project key
+     * @param branch        the branch name
+     * @param metricTag     the metric tag (e.g. {@code "CPU"} or {@code "RAM"})
+     * @param displayHeader whether to render the project header
+     */
+    public static void appendPieChartSection(StringBuilder output, String sonarqubeUrl,
+            String sonarqubeToken, String projectKey, String branch, String metricTag, boolean displayHeader) {
+        try {
+            SonarService sonarService = new SonarService(sonarqubeUrl, sonarqubeToken);
+            PieChartService pieChartService = new PieChartService(sonarService);
+            PieChartData data = pieChartService.getData(projectKey, branch, metricTag);
+
+            log.info("creedengo : PieChart data for project {} / tag {} — critical={} major={} minor={} nbRules={} optimized={}",
+                    projectKey, metricTag,
+                    data.criticalIssues(), data.majorIssues(), data.minorIssues(),
+                    data.nbRules(), data.optimizedRules());
+
+            output.append("<div class=\"creedengo-piechart-widget\">");
+
+            if (displayHeader) {
+                output.append("<h2>")
+                      .append(MacroHelper.getText("piechart.header",
+                              MacroHelper.escapeHtml(projectKey),
+                              MacroHelper.escapeHtml(metricTag)))
+                      .append("</h2>");
+            }
+
+            output.append("<div class=\"creedengo-piechart-body\">");
+            output.append(buildDonutHtml(data));
+            output.append(buildLegendHtml(data, metricTag));
+            output.append("</div>"); // .creedengo-piechart-body
+            output.append("</div>"); // .creedengo-piechart-widget
+
+        } catch (SonarApiException e) {
+            log.error("creedengo : Failed to retrieve PieChart data for project {}", projectKey, e);
+            output.append("<div class=\"aui-message aui-message-error\">")
+                  .append("<p><strong>Erreur :</strong> Impossible de récupérer les données SonarQube.</p>")
+                  .append("<p>").append(MacroHelper.escapeHtml(e.getMessage())).append("</p>")
+                  .append("</div>");
+        }
+    }
+
+    // ------------------------------------------------------------------ helpers
+
+    private static String buildDonutHtml(PieChartData data) {
+        int total = data.totalIssues();
+        String gradient = buildConicGradient(data.minorIssues(), data.majorIssues(), data.criticalIssues(), total);
+
+        return "<div class=\"creedengo-donut\" style=\"background: " + gradient + "\">"
+             + "<div class=\"creedengo-donut-inner\">"
+             + "<div class=\"creedengo-donut-value\">" + total + "</div>"
+             + "<div class=\"creedengo-donut-label\">" + MacroHelper.getText("piechart.donut.label") + "</div>"
+             + "</div>"
+             + "</div>";
+    }
+
+    private static String buildConicGradient(int minor, int major, int critical, int total) {
+        if (total == 0) {
+            return "conic-gradient(#6fcf47 0deg 360deg)";
+        }
+        double t = (double) total;
+        double dMinor    = (minor    / t) * 360.0;
+        double dMajor    = (major    / t) * 360.0;
+        double dCritical = (critical / t) * 360.0;
+        double stopMinor           = dMinor;
+        double stopMajor           = dMinor + dMajor;
+        double stopCritical        = dMinor + dMajor + dCritical;
+
+        return String.format(Locale.US,
+            "conic-gradient("
+            + "#f2c94c 0deg %.2fdeg, "
+            + "#f2994a %.2fdeg %.2fdeg, "
+            + "#eb5757 %.2fdeg %.2fdeg, "
+            + "#6fcf47 %.2fdeg 360deg"
+            + ")",
+            stopMinor,
+            stopMinor, stopMajor,
+            stopMajor, stopCritical,
+            stopCritical);
+    }
+
+    private static String buildLegendHtml(PieChartData data, String metricTag) {
+        StringBuilder legend = new StringBuilder();
+        legend.append("<div class=\"creedengo-piechart-legend\">")
+              .append("<div class=\"piechart-tag-badge\">").append(MacroHelper.escapeHtml(metricTag)).append("</div>")
+              .append("<ul class=\"piechart-legend-list\">")
+              .append(legendItem("#eb5757", MacroHelper.getText("piechart.legend.critical"), data.criticalIssues()))
+              .append(legendItem("#f2994a", MacroHelper.getText("piechart.legend.major"),    data.majorIssues()))
+              .append(legendItem("#f2c94c", MacroHelper.getText("piechart.legend.minor"),    data.minorIssues()))
+              .append(legendItem("#6fcf47", MacroHelper.getText("piechart.legend.optimized"), data.optimizedRules()))
+              .append("</ul>")
+              .append("<div class=\"piechart-rules-total\">")
+              .append(MacroHelper.getText("piechart.rules.total", String.valueOf(data.nbRules())))
+              .append("</div>")
+              .append("</div>");
+        return legend.toString();
+    }
+
+    private static String legendItem(String color, String label, int count) {
+        return "<li class=\"piechart-legend-item\">"
+             + "<span class=\"piechart-legend-dot\" style=\"background:" + color + "\"></span>"
+             + "<span class=\"piechart-legend-text\">" + MacroHelper.escapeHtml(label) + "</span>"
+             + "<span class=\"piechart-legend-count\">" + count + "</span>"
+             + "</li>";
+    }
+
+    @Override
+    public BodyType getBodyType() {
+        return BodyType.NONE;
+    }
+
+    @Override
+    public OutputType getOutputType() {
+        return OutputType.BLOCK;
+    }
+}
diff --git a/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/macro/PriorityRulesMacro.java b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/macro/PriorityRulesMacro.java
new file mode 100644
index 0000000..b507125
--- /dev/null
+++ b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/macro/PriorityRulesMacro.java
@@ -0,0 +1,203 @@
+/*
+* Creedengo Dashboard plugin - Provides dashboard to monitor and help reduce the environmental footprint of your programs
+* Copyright © 2025 Green Code Initiative (https://green-code-initiative.org)
+*
+* This program is free software: you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation, either version 3 of the License, or
+* (at your option) any later version.
+*
+* This program is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+* GNU General Public License for more details.
+*
+* You should have received a copy of the GNU General Public License
+* along with this program. If not, see <http://www.gnu.org/licenses/>.
+*/
+package org.greencodeinitiative.creedengo.confluence.plugin.macro;
+
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+import java.util.Map;
+
+import org.greencodeinitiative.creedengo.confluence.plugin.service.PriorityRulesService;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarApiException;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarService;
+import org.json.JSONObject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.beans.factory.annotation.Autowired;
+
+import com.atlassian.confluence.content.render.xhtml.ConversionContext;
+import com.atlassian.confluence.macro.Macro;
+import com.atlassian.confluence.macro.MacroExecutionException;
+import com.atlassian.plugin.spring.scanner.annotation.imports.ComponentImport;
+import com.atlassian.webresource.api.assembler.PageBuilderService;
+
+public class PriorityRulesMacro implements Macro {
+    
+    private final PageBuilderService pageBuilderService;
+    private static final Logger log = LoggerFactory.getLogger(PriorityRulesMacro.class);
+
+    
+    @Autowired
+    public PriorityRulesMacro(@ComponentImport PageBuilderService pageBuilderService) {
+        this.pageBuilderService = pageBuilderService;
+    }
+    
+    @Override
+    public String execute(Map<String, String> map, String s, ConversionContext conversionContext) throws MacroExecutionException {
+        MacroHelper.requireWebResources(pageBuilderService);
+        log.info("creedengo : Executing PriorityRulesMacro with parameters: {}", map.toString());
+        
+        String sonarqubeUrl = map.get("sonarqube_url");
+        String sonarqubeToken = map.get("sonarqube_token");
+        String projectKey = map.get("project_key");
+        String branch = map.getOrDefault("branch", "main");
+        
+        StringBuilder output = new StringBuilder();
+        if (sonarqubeUrl != null) {
+            if (!MacroHelper.isValidUrl(sonarqubeUrl)) {
+                log.warn("creedengo : Invalid SonarQube URL format: {}", sonarqubeUrl);
+                output.append("<div class=\"aui-message aui-message-error\">")
+                .append("<p><strong>Erreur :</strong> L'URL SonarQube fournie est invalide : ")
+                .append(MacroHelper.escapeHtml(sonarqubeUrl))
+                .append("</p>")
+                .append("<p>Format attendu : <code>https://sonar.example.com</code></p>")
+                .append("</div>");
+            } else {
+                String serverStatus = MacroHelper.verifySonarServer(sonarqubeUrl, sonarqubeToken);
+                if (serverStatus != null) {
+                    log.warn("creedengo : SonarQube server verification failed: {}", serverStatus);
+                    output.append("<div class=\"aui-message aui-message-warning\">")
+                    .append("<p><strong>Attention :</strong> Impossible de joindre le serveur SonarQube.</p>")
+                    .append("<p>").append(MacroHelper.escapeHtml(serverStatus)).append("</p>")
+                    .append("</div>");
+                } else {
+
+                    appendPriorityRulesSection(output, sonarqubeUrl, sonarqubeToken, projectKey, branch, true);
+                }
+            }
+        } else {
+            output.append("<h1>")
+            .append(MacroHelper.getText("priorityrules.header.emptyurl"))
+            .append("</h1>");
+        }
+        return output.toString();
+    }
+    
+    public static void appendPriorityRulesSection(StringBuilder output, String sonarqubeUrl,
+        String sonarqubeToken, String projectKey, String branch, boolean displayHeader) {
+            try {
+                SonarService sonarService = new SonarService(sonarqubeUrl, sonarqubeToken);
+                PriorityRulesService priorityRulesService = new PriorityRulesService(sonarService);
+                log.info("creedengo : Retrieve rules for project {} on branch {}", projectKey, branch);
+                Map<String, List<JSONObject>>rulesByPriority = priorityRulesService.getRulesByPriority(projectKey, branch);
+                
+                // Collect all rules with at least 1 issue, sorted by priority then by issueCount
+                List<JSONObject> allRulesWithIssues = new ArrayList<>();
+                String[] priorityOrder = {"blocker", "critical", "major", "minor", "info"};
+                
+                for (String priority : priorityOrder) {
+                    List<JSONObject> rules = rulesByPriority.get(priority);
+                    if (rules != null) {
+                        for (JSONObject rule : rules) {
+                            if (rule.optInt("issueCount", 0) > 0) {
+                                rule.put("_priorityRank", getPriorityRank(priority));
+                                allRulesWithIssues.add(rule);
+                            }
+                        }
+                    }
+                }
+                
+                // Sort by priority rank (lower = more critical), then by issueCount descending
+                allRulesWithIssues.sort(Comparator
+                    .comparingInt((JSONObject r) -> r.optInt("_priorityRank", 999))
+                    .thenComparingInt((JSONObject r) -> -r.optInt("issueCount", 0)));
+                
+                // Keep only top 3
+                List<JSONObject> topRules = allRulesWithIssues.subList(0, Math.min(3, allRulesWithIssues.size()));
+                
+                output.append("<div class='creedengo-priority-macro'>");
+                
+                if (topRules.isEmpty()) {
+                    output.append("<div class='priority-info'>");
+                    output.append("<p>Aucune règle de durabilité détectée sur ce projet.</p>");
+                    output.append("</div>");
+                } else {
+                                        // i18n externalisation du label principal
+                    output.append("<div class='priority-header'>");
+                    if (displayHeader) {
+                        output.append("<h1>").append(MacroHelper.getText("priorityrules.header", MacroHelper.escapeHtml(projectKey))).append("</h1>");
+                    }
+                    output.append("<h3>Top ").append(topRules.size()).append(" règles critiques</h3>");
+                    output.append("</div>");
+                    output.append("<div class='priority-items'>");
+                    
+                    int rank = 1;
+                    for (JSONObject rule : topRules) {
+                        String name = rule.optString("name", "");
+                        String key = rule.optString("key", "");
+                        String severity = rule.optString("severity", "info").toLowerCase();
+                        int issueCount = rule.optInt("issueCount", 0);
+                        String description = rule.optString("htmlDesc", "");
+                        
+                        output.append("<div class='priority-item rank-").append(rank).append(" severity-").append(severity).append("'>");
+                        output.append("<div class='priority-rank'>").append(rank).append("</div>");
+                        output.append("<div class='priority-content'>");
+                        output.append("<div class='priority-title'>").append(MacroHelper.escapeHtml(name)).append("</div>");
+                        output.append("<div class='priority-meta'>");
+                        output.append("<span class='rule-key'>[").append(key).append("]</span>");
+                        output.append("<span class='rule-severity severity-").append(severity).append("'>").append(severity.toUpperCase()).append("</span>");
+                        output.append("<span class='rule-count'>").append(issueCount).append(" issue(s)</span>");
+                        output.append("</div>");
+                        if (!description.isEmpty()) {
+                            output.append("<div class='priority-desc'>").append(description).append("</div>");
+                        }
+                        output.append("</div>");
+                        output.append("</div>");
+                        rank++;
+                    }
+                    
+                    output.append("</div>");
+                }
+                
+                output.append("</div>");
+            } catch (SonarApiException e) {
+                log.error("creedengo : Failed to get priority rules for project {}", projectKey, e);
+                output.append("<div class=\"aui-message aui-message-warning\">")
+                .append("<p><strong>Attention :</strong> Impossible de calculer les règles de priorité Creedengo.</p>")
+                .append("<p>").append(MacroHelper.escapeHtml(e.getMessage())).append("</p>")
+                .append("</div>");
+            }
+        }
+        
+        /**
+         * Return a numeric rank for a priority level (lower = more critical).
+         */
+        private static int getPriorityRank(String priority) {
+            switch (priority.toLowerCase()) {
+                case "blocker":
+                    return 0;
+                case "critical":
+                    return 1;
+                case "major":
+                    return 2;
+                case "minor":
+                    return 3;
+                case "info":
+                    return 4;
+                default:
+                    return 999;
+            }
+        }
+
+        
+        @Override
+        public Macro.BodyType getBodyType() { return Macro.BodyType.NONE; }
+        
+        @Override
+        public Macro.OutputType getOutputType() { return Macro.OutputType.BLOCK; }
+    }
diff --git a/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/service/PieChartService.java b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/service/PieChartService.java
new file mode 100644
index 0000000..d0e0039
--- /dev/null
+++ b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/service/PieChartService.java
@@ -0,0 +1,99 @@
+/*
+ * Creedengo Dashboard plugin - Provides dashboard to monitor and help reduce the environmental footprint of your programs
+ * Copyright © 2025 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.greencodeinitiative.creedengo.confluence.plugin.service;
+
+import java.util.List;
+import java.util.Map;
+
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarApiException;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarService;
+import org.json.JSONObject;
+
+/**
+ * Retrieves all data needed to render a PieChart (donut) widget for a given metric tag.
+ *
+ * <p>Supported metric tags are typically {@code cpu} and {@code ram}, corresponding to
+ * SonarQube rule tags that categorize sustainability issues by resource consumption.</p>
+ */
+public class PieChartService {
+
+    private final SonarService sonarService;
+
+    public PieChartService(SonarService sonarService) {
+        this.sonarService = sonarService;
+    }
+
+    /**
+     * All data required to render a PieChart donut for a given tag.
+     */
+    public static final class PieChartData {
+        private final int criticalIssues;
+        private final int majorIssues;
+        private final int minorIssues;
+        private final int nbRules;
+        private final int optimizedRules;
+
+        public PieChartData(int criticalIssues, int majorIssues, int minorIssues, int nbRules, int optimizedRules) {
+            this.criticalIssues = criticalIssues;
+            this.majorIssues = majorIssues;
+            this.minorIssues = minorIssues;
+            this.nbRules = nbRules;
+            this.optimizedRules = optimizedRules;
+        }
+
+        public int criticalIssues()  { return criticalIssues; }
+        public int majorIssues()     { return majorIssues; }
+        public int minorIssues()     { return minorIssues; }
+        public int nbRules()         { return nbRules; }
+        public int optimizedRules()  { return optimizedRules; }
+
+        public int totalIssues() {
+            return criticalIssues + majorIssues + minorIssues;
+        }
+    }
+
+    /**
+     * Fetch PieChart data for the given project, branch, and metric tag.
+     *
+     * @param project   the SonarQube project key
+     * @param branch    the branch name
+     * @param metricTag the tag to filter on (e.g. {@code "CPU"} or {@code "RAM"})
+     * @return a {@link PieChartData} instance with all aggregated counts
+     * @throws SonarApiException if any SonarQube API call fails
+     */
+    public PieChartData getData(String project, String branch, String metricTag) throws SonarApiException {
+        String tag = metricTag.toLowerCase();
+
+        // 1. Severity facets filtered by the specific metric tag
+        Map<String, Integer> severities = sonarService.issues().getIssuesFacetByTag("severities", tag, project, branch);
+        int criticalIssues = severities.getOrDefault("critical", 0) + severities.getOrDefault("blocker", 0);
+        int majorIssues = severities.getOrDefault("major", 0);
+        int minorIssues = severities.getOrDefault("minor", 0) + severities.getOrDefault("info", 0);
+
+        // 2. Total rules for this tag
+        List<JSONObject> rules = sonarService.rules().findRulesByTag(tag);
+        int nbRules = rules.size();
+
+        // 3. Rules with at least 1 open issue -> infer optimized rules count
+        Map<String, Integer> issuesByRule = sonarService.issues().getIssueCountByRuleKeyByTag(tag, project, branch);
+        long rulesWithIssues = issuesByRule.values().stream().filter(count -> count > 0).count();
+        int optimizedRules = Math.max(0, nbRules - (int) rulesWithIssues);
+
+        return new PieChartData(criticalIssues, majorIssues, minorIssues, nbRules, optimizedRules);
+    }
+}
diff --git a/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/service/PriorityRulesService.java b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/service/PriorityRulesService.java
new file mode 100644
index 0000000..1f81452
--- /dev/null
+++ b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/service/PriorityRulesService.java
@@ -0,0 +1,71 @@
+/*
+ * Creedengo Dashboard plugin - Service de récupération des règles par priorité
+ * Copyright © 2025 Green Code Initiative
+ */
+package org.greencodeinitiative.creedengo.confluence.plugin.service;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarApiException;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarService;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.api.SonarIssuesApi;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.api.SonarRulesApi;
+import org.json.JSONObject;
+
+/**
+ * Service pour récupérer les règles SonarQube groupées par priorité (severity),
+ * enrichies du nombre d'issues ouvertes associées.
+ *
+ * <p>Les règles sont filtrées via les tags de durabilité définis dans
+ * {@code SonarConstants.SUSTAINABILITY_TAGS} (sustainability, greensight, ecocode, creedengo).
+ * À l'intérieur de chaque groupe de sévérité, les règles sont triées par nombre
+ * d'issues décroissant.</p>
+ */
+public class PriorityRulesService {
+
+    private final SonarRulesApi sonarRulesApi;
+    private final SonarIssuesApi sonarIssuesApi;
+
+    public PriorityRulesService(SonarService sonarService) {
+        this.sonarRulesApi = sonarService.rules();
+        this.sonarIssuesApi = sonarService.issues();
+    }
+
+    /**
+     * Retourne une map des règles groupées par priorité (severity), chaque règle
+     * étant enrichie d'un champ {@code issueCount} indiquant le nombre d'issues
+     * ouvertes associées dans le projet.
+     *
+     * <p>Les règles sont triées par {@code issueCount} décroissant à l'intérieur
+     * de chaque groupe de sévérité.</p>
+     *
+     * @param project le projectKey SonarQube
+     * @param branch  la branche
+     * @return {@code Map<severity, List<JSONObject>>} — chaque JSONObject
+     *         contient les champs de la règle plus {@code issueCount}
+     * @throws SonarApiException en cas d'erreur API
+     */
+    public Map<String, List<JSONObject>> getRulesByPriority(String project, String branch) throws SonarApiException {
+        List<JSONObject> rules = sonarRulesApi.findRules(project, branch);
+        Map<String, Integer> issueCountByRule = sonarIssuesApi.getIssueCountByRuleKey(project, branch);
+
+        Map<String, List<JSONObject>> byPriority = new HashMap<>();
+        for (JSONObject rule : rules) {
+            String severity = rule.optString("severity", "info").toLowerCase();
+            String ruleKey = rule.optString("key", "");
+            int issueCount = issueCountByRule.getOrDefault(ruleKey, 0);
+            rule.put("issueCount", issueCount);
+            byPriority.computeIfAbsent(severity, k -> new ArrayList<>()).add(rule);
+        }
+
+        // Sort rules within each severity by issueCount descending
+        for (List<JSONObject> ruleList : byPriority.values()) {
+            ruleList.sort((a, b) -> Integer.compare(b.optInt("issueCount", 0), a.optInt("issueCount", 0)));
+        }
+
+        return byPriority;
+    }
+}
\ No newline at end of file
diff --git a/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/service/ScoreService.java b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/service/ScoreService.java
new file mode 100644
index 0000000..7c459e1
--- /dev/null
+++ b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/service/ScoreService.java
@@ -0,0 +1,177 @@
+/*
+ * Creedengo Dashboard plugin - Provides dashboard to monitor and help reduce the environmental footprint of your programs
+ * Copyright © 2025 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.greencodeinitiative.creedengo.confluence.plugin.service;
+
+import java.util.Map;
+
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarApiException;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarService;
+
+/**
+ * Java equivalent of {@code score.service.js}.
+ *
+ * <p>Calculates an ABCDE sustainability score for a SonarQube project based on
+ * the number and severity of sustainability-tagged issues relative to the
+ * project size (lines of code).</p>
+ *
+ * <h3>Score rules</h3>
+ * <ul>
+ *   <li><strong>E</strong> – 1 or more blocker severities</li>
+ *   <li><strong>D</strong> – minor ratio &ge; 8%, or &ge; 10 major, or &ge; 1 critical</li>
+ *   <li><strong>C</strong> – &ge; 10 consolidated minors, or &ge; 1 major</li>
+ *   <li><strong>B</strong> – &ge; 1 consolidated minor</li>
+ *   <li><strong>A</strong> – fully optimized (no issues)</li>
+ * </ul>
+ */
+public class ScoreService {
+
+    private final SonarService sonarService;
+
+    public ScoreService(SonarService sonarService) {
+        this.sonarService = sonarService;
+    }
+
+    /**
+     * Calculate the ABCDE score for the given project and branch.
+     *
+     * <p>This is a direct port of the JavaScript {@code calculateProjectScore}
+     * function from {@code score.service.js}.</p>
+     *
+     * @param project the SonarQube project key
+     * @param branch  the Git branch name
+     * @return a score character: A, B, C, D, or E
+     * @throws SonarApiException if a SonarQube API call fails
+     */
+    public String calculateProjectScore(String project, String branch) throws SonarApiException {
+        // 1. Get severity facets (equivalent of getIssuesFacet('severities', config))
+        Map<String, Integer> severityFacets = sonarService.issues()
+                .getIssuesFacet("severities", project, branch, null);
+
+        int info = severityFacets.getOrDefault("info", 0);
+        int minor = severityFacets.getOrDefault("minor", 0);
+        int major = severityFacets.getOrDefault("major", 0);
+        int critical = severityFacets.getOrDefault("critical", 0);
+        int blocker = severityFacets.getOrDefault("blocker", 0);
+
+        int consolidatedMinors = info + minor;
+
+        // 2. Get number of lines of code
+        long numberOfLines = sonarService.measures().getNumberOfLineOfCode(project, branch);
+
+        // 3. Calculate minor ratio (guard against division by zero)
+        double minorRatio = numberOfLines > 0
+                ? (double) consolidatedMinors / numberOfLines
+                : 0.0;
+
+        // 4. Apply score rules (same order as the JavaScript implementation)
+        if (blocker >= 1) {
+            return "E";
+        }
+        if (minorRatio >= 0.08 || major >= 10 || critical >= 1) {
+            return "D";
+        }
+        if (consolidatedMinors >= 10 || major >= 1) {
+            return "C";
+        }
+        if (consolidatedMinors >= 1) {
+            return "B";
+        }
+        return "A";
+    }
+
+    /**
+     * Description texts associated with each score level.
+     *
+     * <p>Direct port of the {@code scoreTexts} constant from
+     * {@code score.service.js}.</p>
+     *
+     * @param score the score character (A–E)
+     * @return a {@link ScoreTexts} record, or {@code null} if the score is unknown
+     */
+    public static ScoreTexts getScoreTexts(String score) {
+        if (score == null) {
+            return null;
+        }
+        switch (score) {
+            case "A":
+                return new ScoreTexts(
+                        "Your app is fully optimized, congratulations!",
+                        "Don't forget to check it again if you update your app.",
+                        "100 % optimized, congrats!"
+                );
+            case "B":
+                return new ScoreTexts(
+                        "Your app is nearly optimized.",
+                        "Well done! You can continue by fixing the recommended rule on the right side. "
+                                + "This is the one that currently has the highest impact on your app.",
+                        "You have between 1 and 9 minor severities."
+                );
+            case "C":
+                return new ScoreTexts(
+                        "Your app is not fully optimized.",
+                        "Keep going! You can continue by fixing the recommended rule on the right side. "
+                                + "This is the one that currently has the highest impact on your app.",
+                        "You have between 10 and 19 minor severities or you have 1 or many major severity."
+                );
+            case "D":
+                return new ScoreTexts(
+                        "Many elements of your application can be optimized.",
+                        "Don't worry! You can start by fixing the recommended rule on the right side. "
+                                + "This is the one that currently has the highest impact on your app.",
+                        "You have more than 20 minor severities or more than 10 major severities "
+                                + "or 1 or many critical severities."
+                );
+            case "E":
+                return new ScoreTexts(
+                        "Several elements of your application can be optimized.",
+                        "Don't worry! You can start by fixing the recommended rule on the right side. "
+                                + "This is the one that currently has the highest impact on your app.",
+                        "You have 1 or more than 1 blocker severities."
+                );
+            default:
+                return null;
+        }
+    }
+
+    /**
+     * Holds the label, description and tips for a given score.
+     */
+    public static class ScoreTexts {
+        private final String label;
+        private final String description;
+        private final String tips;
+
+        public ScoreTexts(String label, String description, String tips) {
+            this.label = label;
+            this.description = description;
+            this.tips = tips;
+        }
+
+        public String getLabel() {
+            return label;
+        }
+
+        public String getDescription() {
+            return description;
+        }
+
+        public String getTips() {
+            return tips;
+        }
+    }
+}
diff --git a/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarApiException.java b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarApiException.java
new file mode 100644
index 0000000..951e49f
--- /dev/null
+++ b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarApiException.java
@@ -0,0 +1,32 @@
+/*
+ * Creedengo Dashboard plugin - Provides dashboard to monitor and help reduce the environmental footprint of your programs
+ * Copyright © 2025 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.greencodeinitiative.creedengo.confluence.plugin.sonar;
+
+/**
+ * Exception thrown when a SonarQube API call fails.
+ */
+public class SonarApiException extends Exception {
+
+    public SonarApiException(String message) {
+        super(message);
+    }
+
+    public SonarApiException(String message, Throwable cause) {
+        super(message, cause);
+    }
+}
diff --git a/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarClient.java b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarClient.java
new file mode 100644
index 0000000..4ad0bdb
--- /dev/null
+++ b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarClient.java
@@ -0,0 +1,208 @@
+/*
+ * Creedengo Dashboard plugin - Provides dashboard to monitor and help reduce the environmental footprint of your programs
+ * Copyright © 2025 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.greencodeinitiative.creedengo.confluence.plugin.sonar;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.UnsupportedEncodingException;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import org.json.JSONObject;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+/**
+ * HTTP client for SonarQube Web API.
+ *
+ * <p>Equivalent of the JavaScript {@code sonar-request.js} polyfill.
+ * Authenticates via a Bearer token and returns parsed JSON responses.</p>
+ *
+ * <p>Usage:</p>
+ * <pre>{@code
+ * SonarClient client = new SonarClient("https://sonar.example.com", "squ_mytoken");
+ * JSONObject json = client.getJSON("api/issues/search", params);
+ * }</pre>
+ *
+ * @see <a href="https://docs.sonarsource.com/sonarqube/latest/extension-guide/web-api/">SonarQube Web API</a>
+ */
+public class SonarClient {
+
+    private static final Logger log = LoggerFactory.getLogger(SonarClient.class);
+
+    private static final int CONNECT_TIMEOUT_MS = 10_000;
+    private static final int READ_TIMEOUT_MS = 30_000;
+
+    private final String baseUrl;
+    private final String token;
+
+    /**
+     * Create a new SonarQube API client.
+     *
+     * @param baseUrl the SonarQube server base URL (e.g. {@code https://sonar.example.com})
+     * @param token   the authentication token (Bearer)
+     */
+    public SonarClient(String baseUrl, String token) {
+        // strip trailing slash
+        this.baseUrl = baseUrl != null && baseUrl.endsWith("/")
+                ? baseUrl.substring(0, baseUrl.length() - 1)
+                : baseUrl;
+        this.token = token;
+    }
+
+    /**
+     * Execute a GET request and return the parsed JSON response.
+     *
+     * @param route  the API route (e.g. {@code "api/issues/search"})
+     * @param params query parameters (may be {@code null} or empty)
+     * @return the parsed {@link JSONObject}
+     * @throws SonarApiException if the request fails
+     */
+    public JSONObject getJSON(String route, Map<String, String> params) throws SonarApiException {
+        String url = buildUrl(route, params);
+        log.debug("SonarQube GET {}", url);
+
+        HttpURLConnection connection = null;
+        try {
+            connection = (HttpURLConnection) new URL(url).openConnection();
+            connection.setRequestMethod("GET");
+            connection.setRequestProperty("Accept", "application/json");
+            if (token != null && !token.isEmpty()) {
+                connection.setRequestProperty("Authorization", "Bearer " + token);
+            }
+            connection.setConnectTimeout(CONNECT_TIMEOUT_MS);
+            connection.setReadTimeout(READ_TIMEOUT_MS);
+
+            int status = connection.getResponseCode();
+            if (status < 200 || status >= 300) {
+                String errorBody = readStream(connection);
+                throw new SonarApiException(
+                        "SonarQube API returned HTTP " + status + " for " + route + ": " + errorBody);
+            }
+
+            String body = readBody(connection);
+            return new JSONObject(body);
+
+        } catch (SonarApiException e) {
+            throw e;
+        } catch (IOException e) {
+            throw new SonarApiException("Failed to call SonarQube API: " + route, e);
+        } finally {
+            if (connection != null) {
+                connection.disconnect();
+            }
+        }
+    }
+
+    // ---- URL building ----
+
+    private String buildUrl(String route, Map<String, String> params) {
+        StringBuilder sb = new StringBuilder(baseUrl).append('/').append(route);
+        if (params != null && !params.isEmpty()) {
+            sb.append('?').append(encodeParams(params));
+        }
+        return sb.toString();
+    }
+
+    private static String encodeParams(Map<String, String> params) {
+        StringBuilder sb = new StringBuilder();
+        for (Map.Entry<String, String> entry : params.entrySet()) {
+            if (entry.getValue() == null) {
+                continue;
+            }
+            if (sb.length() > 0) {
+                sb.append('&');
+            }
+            sb.append(urlEncode(entry.getKey()))
+              .append('=')
+              .append(urlEncode(entry.getValue()));
+        }
+        return sb.toString();
+    }
+
+    private static String urlEncode(String value) {
+        try {
+            return URLEncoder.encode(value, StandardCharsets.UTF_8.name());
+        } catch (UnsupportedEncodingException e) {
+            // UTF-8 is always supported
+            throw new IllegalStateException(e);
+        }
+    }
+
+    // ---- Response reading ----
+
+    private static String readBody(HttpURLConnection connection) throws IOException {
+        try (BufferedReader reader = new BufferedReader(
+                new InputStreamReader(connection.getInputStream(), StandardCharsets.UTF_8))) {
+            return readAll(reader);
+        }
+    }
+
+    private static String readStream(HttpURLConnection connection) {
+        try (BufferedReader reader = new BufferedReader(
+                new InputStreamReader(connection.getErrorStream(), StandardCharsets.UTF_8))) {
+            return readAll(reader);
+        } catch (Exception e) {
+            return "(unable to read error body)";
+        }
+    }
+
+    private static String readAll(BufferedReader reader) throws IOException {
+        StringBuilder sb = new StringBuilder();
+        String line;
+        while ((line = reader.readLine()) != null) {
+            sb.append(line);
+        }
+        return sb.toString();
+    }
+
+    // ---- Server health check ----
+
+    /**
+     * Check that the SonarQube server is reachable and responding.
+     *
+     * <p>Calls {@code api/system/status} and verifies the server returns a
+     * valid JSON response with a {@code status} field.</p>
+     *
+     * @return the server status string (e.g. {@code "UP"}, {@code "STARTING"})
+     * @throws SonarApiException if the server is unreachable or returns an error
+     */
+    public String checkServerStatus() throws SonarApiException {
+        JSONObject json = getJSON("api/system/status", null);
+        if (!json.has("status")) {
+            throw new SonarApiException("Unexpected response from api/system/status: missing 'status' field");
+        }
+        return json.getString("status");
+    }
+
+    // ---- Helper for building parameter maps ----
+
+    /**
+     * Convenience method to create a mutable parameter map.
+     *
+     * @return a new empty {@link LinkedHashMap}
+     */
+    public static Map<String, String> params() {
+        return new LinkedHashMap<>();
+    }
+}
diff --git a/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarConstants.java b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarConstants.java
new file mode 100644
index 0000000..d7ba79c
--- /dev/null
+++ b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarConstants.java
@@ -0,0 +1,51 @@
+/*
+ * Creedengo Dashboard plugin - Provides dashboard to monitor and help reduce the environmental footprint of your programs
+ * Copyright © 2025 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.greencodeinitiative.creedengo.confluence.plugin.sonar;
+
+/**
+ * Constants used across SonarQube API calls.
+ *
+ * <p>Sustainability tags used to filter issues or rules:</p>
+ * <ul>
+ *   <li>{@code sustainability} — generic tag used on some sonar rules</li>
+ *   <li>{@code greensight} — tag used by the Capgemini Greensight plugin</li>
+ *   <li>{@code ecocode} — tag occasionally used when creedengo was called ecocode</li>
+ *   <li>{@code creedengo} — tag identifying rules provided by Creedengo plugins</li>
+ * </ul>
+ */
+public final class SonarConstants {
+
+    private SonarConstants() {
+        // utility class
+    }
+
+    /**
+     * Comma-separated sustainability tags for filtering issues and rules.
+     */
+    public static final String SUSTAINABILITY_TAGS = "sustainability,greensight,ecocode,creedengo";
+
+    /**
+     * Default issue statuses filter (current SonarQube API).
+     */
+    public static final String ISSUE_STATUSES = "OPEN,CONFIRMED";
+
+    /**
+     * Legacy issue statuses filter (for older SonarQube versions).
+     */
+    public static final String LEGACY_STATUSES = "OPEN,CONFIRMED,REOPENED";
+}
diff --git a/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarService.java b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarService.java
new file mode 100644
index 0000000..9a2598f
--- /dev/null
+++ b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarService.java
@@ -0,0 +1,97 @@
+/*
+ * Creedengo Dashboard plugin - Provides dashboard to monitor and help reduce the environmental footprint of your programs
+ * Copyright © 2025 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.greencodeinitiative.creedengo.confluence.plugin.sonar;
+
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.api.SonarIssuesApi;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.api.SonarMeasuresApi;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.api.SonarProjectBranchesApi;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.api.SonarProjectInfoApi;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.api.SonarProjectPullRequestsApi;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.api.SonarRulesApi;
+
+/**
+ * Facade providing access to all SonarQube API services.
+ *
+ * <p>Usage from the Confluence macro:</p>
+ * <pre>{@code
+ * SonarService sonar = new SonarService(sonarqubeUrl, sonarqubeToken);
+ * List<JsonObject> issues = sonar.issues().findIssues(projectKey, branch);
+ * long ncloc = sonar.measures().getNumberOfLineOfCode(projectKey, branch);
+ * }</pre>
+ */
+public class SonarService {
+
+    private final SonarClient client;
+    private final SonarIssuesApi issuesApi;
+    private final SonarMeasuresApi measuresApi;
+    private final SonarRulesApi rulesApi;
+    private final SonarProjectBranchesApi branchesApi;
+    private final SonarProjectInfoApi projectInfoApi;
+    private final SonarProjectPullRequestsApi pullRequestsApi;
+
+    /**
+     * Create a SonarService with the given SonarQube URL and authentication token.
+     *
+     * @param sonarqubeUrl   the SonarQube server base URL
+     * @param sonarqubeToken the authentication token (Bearer)
+     */
+    public SonarService(String sonarqubeUrl, String sonarqubeToken) {
+        this.client = new SonarClient(sonarqubeUrl, sonarqubeToken);
+        this.issuesApi = new SonarIssuesApi(client);
+        this.measuresApi = new SonarMeasuresApi(client);
+        this.rulesApi = new SonarRulesApi(client);
+        this.branchesApi = new SonarProjectBranchesApi(client);
+        this.projectInfoApi = new SonarProjectInfoApi(client);
+        this.pullRequestsApi = new SonarProjectPullRequestsApi(client);
+    }
+
+    /** @return the Issues Search API */
+    public SonarIssuesApi issues() {
+        return issuesApi;
+    }
+
+    /** @return the Measures Component API */
+    public SonarMeasuresApi measures() {
+        return measuresApi;
+    }
+
+    /** @return the Rules Search/Show API */
+    public SonarRulesApi rules() {
+        return rulesApi;
+    }
+
+    /** @return the Project Branches API */
+    public SonarProjectBranchesApi branches() {
+        return branchesApi;
+    }
+
+    /** @return the Project Info API */
+    public SonarProjectInfoApi projectInfo() {
+        return projectInfoApi;
+    }
+
+    /** @return the Project Pull Requests API */
+    public SonarProjectPullRequestsApi pullRequests() {
+        return pullRequestsApi;
+    }
+
+    /** @return the underlying HTTP client (for advanced usage) */
+    public SonarClient getClient() {
+        return client;
+    }
+}
diff --git a/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/api/SonarIssuesApi.java b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/api/SonarIssuesApi.java
new file mode 100644
index 0000000..daa1275
--- /dev/null
+++ b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/api/SonarIssuesApi.java
@@ -0,0 +1,294 @@
+/*
+ * Creedengo Dashboard plugin - Provides dashboard to monitor and help reduce the environmental footprint of your programs
+ * Copyright © 2025 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.greencodeinitiative.creedengo.confluence.plugin.sonar.api;
+
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarApiException;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarClient;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarConstants;
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+/**
+ * Java equivalent of {@code sonar.issues.search.api.js}.
+ *
+ * <p>Calls {@code api/issues/search} to retrieve sustainability-tagged issues
+ * that are not closed.</p>
+ *
+ * @see <a href="https://docs.sonarsource.com/sonarqube/latest/extension-guide/web-api/#api-issues">SonarQube Issues API</a>
+ */
+public class SonarIssuesApi {
+
+    private static final String ROUTE = "api/issues/search";
+
+    private final SonarClient client;
+
+    public SonarIssuesApi(SonarClient client) {
+        this.client = client;
+    }
+
+    /**
+     * Return issues detected by SonarQube.
+     * Only gathers sustainability-tagged issues that are NOT closed.
+     *
+     * @param project the SonarQube project key
+     * @param branch  the branch name
+     * @return a list of issues as {@link JSONObject}
+     * @throws SonarApiException if the API call fails
+     */
+    public List<JSONObject> findIssues(String project, String branch) throws SonarApiException {
+        Map<String, String> params = buildSustainabilityParams();
+        params.put("componentKeys", project);
+        params.put("branch", branch);
+        
+        JSONObject response = client.getJSON(ROUTE, params);
+        JSONArray issues = response.optJSONArray("issues");
+
+        List<JSONObject> result = new ArrayList<>();
+        if (issues != null) {
+            for (int i = 0; i < issues.length(); i++) {
+                result.add(issues.getJSONObject(i));
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Get an issues facet for a given project, branch, and facet name.
+     *
+     * <p>Equivalent of the JavaScript {@code getIssuesFacet} function.
+     * Returns a map where keys are facet values (lowercased) and values are counts.</p>
+     *
+     * @param facetName the facet to retrieve (e.g. {@code "severities"}, {@code "types"})
+     * @param project   the SonarQube project key
+     * @param branch    the branch name
+     * @param severity  optional severity filter (may be {@code null})
+     * @return a map of facet value → count
+     * @throws SonarApiException if the API call fails or the facet is not found
+     */
+    public Map<String, Integer> getIssuesFacet(String facetName, String project, String branch, String severity)
+            throws SonarApiException {
+
+        Map<String, String> params = buildSustainabilityParams();
+        params.put("componentKeys", project);
+        params.put("branch", branch);
+        params.put("facets", facetName);
+        params.put("ps", "100"); // no issues parsing, we only want the facets
+        if (severity != null && !severity.isEmpty()) {
+            params.put("severity", severity);
+        }
+
+        JSONObject response = client.getJSON(ROUTE, params);
+        JSONArray facets = response.optJSONArray("facets");
+
+        if (facets == null) {
+            throw new SonarApiException("No facets returned by SonarQube for route " + ROUTE);
+        }
+
+        // Find the facet matching the requested name
+        JSONObject matchingFacet = null;
+        for (int i = 0; i < facets.length(); i++) {
+            JSONObject facetObj = facets.getJSONObject(i);
+            String property = facetObj.optString("property", "");
+            if (facetName.equals(property)) {
+                matchingFacet = facetObj;
+                break;
+            }
+        }
+
+        if (matchingFacet == null) {
+            throw new SonarApiException("Facet " + facetName + " not found in SonarQube response");
+        }
+
+        // Reduce facet values to a map {value_lowercase -> count}
+        Map<String, Integer> result = new LinkedHashMap<>();
+        JSONArray values = matchingFacet.optJSONArray("values");
+        if (values != null) {
+            for (int i = 0; i < values.length(); i++) {
+                JSONObject valObj = values.getJSONObject(i);
+                String val = valObj.getString("val").toLowerCase();
+                int count = valObj.getInt("count");
+                result.put(val, count);
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Return the number of open sustainability issues per rule key for a given project and branch.
+     *
+     * <p>Uses the {@code rules} facet of {@code api/issues/search} to avoid paginating
+     * through all issues. Rule keys are returned with their original casing.</p>
+     *
+     * @param project the SonarQube project key
+     * @param branch  the branch name
+     * @return a map of rule key → open issue count (0 if a rule has no issues)
+     * @throws SonarApiException if the API call fails
+     */
+    public Map<String, Integer> getIssueCountByRuleKey(String project, String branch) throws SonarApiException {
+        Map<String, String> params = buildSustainabilityParams();
+        params.put("componentKeys", project);
+        params.put("branch", branch);
+        params.put("facets", "rules");
+        params.put("ps", "1"); // we only need facets, not the issue list
+
+        JSONObject response = client.getJSON(ROUTE, params);
+        JSONArray facets = response.optJSONArray("facets");
+
+        if (facets == null) {
+            return new LinkedHashMap<>();
+        }
+
+        for (int i = 0; i < facets.length(); i++) {
+            JSONObject facetObj = facets.getJSONObject(i);
+            if ("rules".equals(facetObj.optString("property", ""))) {
+                Map<String, Integer> result = new LinkedHashMap<>();
+                JSONArray values = facetObj.optJSONArray("values");
+                if (values != null) {
+                    for (int j = 0; j < values.length(); j++) {
+                        JSONObject valObj = values.getJSONObject(j);
+                        String val = valObj.getString("val"); // preserve original casing
+                        int count = valObj.getInt("count");
+                        result.put(val, count);
+                    }
+                }
+                return result;
+            }
+        }
+
+        return new LinkedHashMap<>();
+    }
+
+    /**
+     * Get an issues facet filtered by a specific tag (e.g. "cpu" or "ram").
+     *
+     * <p>Unlike {@link #getIssuesFacet}, this method filters by a single explicit tag
+     * instead of the global sustainability tags list.</p>
+     *
+     * @param facetName the facet to retrieve (e.g. {@code "severities"})
+     * @param tag       the specific tag to filter on (e.g. {@code "cpu"})
+     * @param project   the SonarQube project key
+     * @param branch    the branch name
+     * @return a map of facet value → count
+     * @throws SonarApiException if the API call fails or the facet is not found
+     */
+    public Map<String, Integer> getIssuesFacetByTag(String facetName, String tag, String project, String branch)
+            throws SonarApiException {
+
+        Map<String, String> params = buildTagParams(tag);
+        params.put("componentKeys", project);
+        params.put("branch", branch);
+        params.put("facets", facetName);
+        params.put("ps", "1");
+
+        JSONObject response = client.getJSON(ROUTE, params);
+        JSONArray facets = response.optJSONArray("facets");
+
+        if (facets == null) {
+            throw new SonarApiException("No facets returned by SonarQube for route " + ROUTE);
+        }
+
+        JSONObject matchingFacet = null;
+        for (int i = 0; i < facets.length(); i++) {
+            JSONObject facetObj = facets.getJSONObject(i);
+            if (facetName.equals(facetObj.optString("property", ""))) {
+                matchingFacet = facetObj;
+                break;
+            }
+        }
+
+        if (matchingFacet == null) {
+            throw new SonarApiException("Facet " + facetName + " not found in SonarQube response");
+        }
+
+        Map<String, Integer> result = new LinkedHashMap<>();
+        JSONArray values = matchingFacet.optJSONArray("values");
+        if (values != null) {
+            for (int i = 0; i < values.length(); i++) {
+                JSONObject valObj = values.getJSONObject(i);
+                result.put(valObj.getString("val").toLowerCase(), valObj.getInt("count"));
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Return the number of open issues per rule key filtered by a specific tag.
+     *
+     * @param tag     the specific tag to filter on (e.g. {@code "cpu"})
+     * @param project the SonarQube project key
+     * @param branch  the branch name
+     * @return a map of rule key → open issue count
+     * @throws SonarApiException if the API call fails
+     */
+    public Map<String, Integer> getIssueCountByRuleKeyByTag(String tag, String project, String branch)
+            throws SonarApiException {
+
+        Map<String, String> params = buildTagParams(tag);
+        params.put("componentKeys", project);
+        params.put("branch", branch);
+        params.put("facets", "rules");
+        params.put("ps", "1");
+
+        JSONObject response = client.getJSON(ROUTE, params);
+        JSONArray facets = response.optJSONArray("facets");
+
+        if (facets == null) {
+            return new LinkedHashMap<>();
+        }
+
+        for (int i = 0; i < facets.length(); i++) {
+            JSONObject facetObj = facets.getJSONObject(i);
+            if ("rules".equals(facetObj.optString("property", ""))) {
+                Map<String, Integer> result = new LinkedHashMap<>();
+                JSONArray values = facetObj.optJSONArray("values");
+                if (values != null) {
+                    for (int j = 0; j < values.length(); j++) {
+                        JSONObject valObj = values.getJSONObject(j);
+                        result.put(valObj.getString("val"), valObj.getInt("count"));
+                    }
+                }
+                return result;
+            }
+        }
+        return new LinkedHashMap<>();
+    }
+
+    // ---- private helpers ----
+
+    private static Map<String, String> buildSustainabilityParams() {
+        Map<String, String> params = SonarClient.params();
+        params.put("issueStatuses", SonarConstants.ISSUE_STATUSES);
+        params.put("statuses", SonarConstants.LEGACY_STATUSES);
+        params.put("tags", SonarConstants.SUSTAINABILITY_TAGS);
+        return params;
+    }
+
+    private static Map<String, String> buildTagParams(String tag) {
+        Map<String, String> params = SonarClient.params();
+        params.put("issueStatuses", SonarConstants.ISSUE_STATUSES);
+        params.put("statuses", SonarConstants.LEGACY_STATUSES);
+        params.put("tags", tag);
+        return params;
+    }
+}
diff --git a/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/api/SonarMeasuresApi.java b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/api/SonarMeasuresApi.java
new file mode 100644
index 0000000..4df29e6
--- /dev/null
+++ b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/api/SonarMeasuresApi.java
@@ -0,0 +1,85 @@
+/*
+ * Creedengo Dashboard plugin - Provides dashboard to monitor and help reduce the environmental footprint of your programs
+ * Copyright © 2025 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.greencodeinitiative.creedengo.confluence.plugin.sonar.api;
+
+import java.util.Map;
+
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarApiException;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarClient;
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+/**
+ * Java equivalent of {@code sonar.measures.component.api.js}.
+ *
+ * <p>Calls {@code api/measures/component} to retrieve project metrics.</p>
+ *
+ * @see <a href="https://docs.sonarsource.com/sonarqube/latest/extension-guide/web-api/#api-measures">SonarQube Measures API</a>
+ */
+public class SonarMeasuresApi {
+
+    private static final String ROUTE = "api/measures/component";
+
+    private final SonarClient client;
+
+    public SonarMeasuresApi(SonarClient client) {
+        this.client = client;
+    }
+
+    /**
+     * Return the number of lines of code (ncloc metric) for a project.
+     *
+     * @param project the SonarQube project key
+     * @param branch  the branch name
+     * @return the number of lines of code, or 0 if unavailable
+     * @throws SonarApiException if the API call fails
+     */
+    public long getNumberOfLineOfCode(String project, String branch) throws SonarApiException {
+        Map<String, String> params = SonarClient.params();
+        params.put("component", project);
+        params.put("branch", branch);
+        params.put("metricKeys", "ncloc");
+
+        JSONObject response = client.getJSON(ROUTE, params);
+
+        // Navigate: response.component.measures[0].value
+        JSONObject component = response.optJSONObject("component");
+        if (component == null) {
+            return 0;
+        }
+        JSONArray measures = component.optJSONArray("measures");
+        if (measures == null || measures.length() == 0) {
+            return 0;
+        }
+        for (int i = 0; i < measures.length(); i++) {
+            JSONObject m = measures.getJSONObject(i);
+            if ("ncloc".equals(m.optString("metric"))) {
+                String value = m.optString("value", null);
+                if (value == null) {
+                    return 0;
+                }
+                try {
+                    return Long.parseLong(value);
+                } catch (NumberFormatException e) {
+                    return 0;
+                }
+            }
+        }
+        return 0;
+    }
+}
diff --git a/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/api/SonarProjectBranchesApi.java b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/api/SonarProjectBranchesApi.java
new file mode 100644
index 0000000..c7e2831
--- /dev/null
+++ b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/api/SonarProjectBranchesApi.java
@@ -0,0 +1,69 @@
+/*
+ * Creedengo Dashboard plugin - Provides dashboard to monitor and help reduce the environmental footprint of your programs
+ * Copyright © 2025 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.greencodeinitiative.creedengo.confluence.plugin.sonar.api;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarApiException;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarClient;
+
+/**
+ * Java equivalent of {@code sonar.project-branches.list.api.js}.
+ *
+ * <p>Calls {@code api/project_branches/list} to retrieve branches of a project.</p>
+ *
+ * @see <a href="https://docs.sonarsource.com/sonarqube/latest/extension-guide/web-api/#api-project_branches">SonarQube Project Branches API</a>
+ */
+public class SonarProjectBranchesApi {
+
+    private static final String ROUTE = "api/project_branches/list";
+
+    private final SonarClient client;
+
+    public SonarProjectBranchesApi(SonarClient client) {
+        this.client = client;
+    }
+
+    /**
+     * Get the list of branches for a given project.
+     *
+     * @param project the SonarQube project key
+     * @return a list of branches as {@link JSONObject}
+     * @throws SonarApiException if the API call fails
+     */
+    public List<JSONObject> getProjectBranches(String project) throws SonarApiException {
+        Map<String, String> params = SonarClient.params();
+        params.put("project", project);
+
+        JSONObject response = client.getJSON(ROUTE, params);
+        JSONArray branches = response.optJSONArray("branches");
+
+        List<JSONObject> result = new ArrayList<>();
+        if (branches != null) {
+            for (int i = 0; i < branches.length(); i++) {
+                result.add(branches.getJSONObject(i));
+            }
+        }
+        return result;
+    }
+}
diff --git a/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/api/SonarProjectInfoApi.java b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/api/SonarProjectInfoApi.java
new file mode 100644
index 0000000..c965ff9
--- /dev/null
+++ b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/api/SonarProjectInfoApi.java
@@ -0,0 +1,69 @@
+/*
+ * Creedengo Dashboard plugin - Provides dashboard to monitor and help reduce the environmental footprint of your programs
+ * Copyright © 2025 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.greencodeinitiative.creedengo.confluence.plugin.sonar.api;
+
+import java.util.Map;
+
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarApiException;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarClient;
+import org.json.JSONObject;
+
+/**
+ * Java equivalent of {@code sonar.components.show.api.js}.
+ *
+ * <p>Calls {@code api/components/show} to retrieve project metadata (name, description, etc).</p>
+ *
+ * @see <a href="https://docs.sonarsource.com/sonarqube/latest/extension-guide/web-api/#api-components">SonarQube Components API</a>
+ */
+public class SonarProjectInfoApi {
+
+    private static final String ROUTE = "api/components/show";
+
+    private final SonarClient client;
+
+    public SonarProjectInfoApi(SonarClient client) {
+        this.client = client;
+    }
+
+    /**
+     * Return project information (name, description, etc.) for a given project key.
+     *
+     * @param projectKey the SonarQube project key
+     * @return the project component as a {@link JSONObject}
+     * @throws SonarApiException if the API call fails
+     */
+    public JSONObject getProjectInfo(String projectKey) throws SonarApiException {
+        Map<String, String> params = SonarClient.params();
+        params.put("component", projectKey);
+
+        JSONObject response = client.getJSON(ROUTE, params);
+        return response.getJSONObject("component");
+    }
+
+    /**
+     * Return the display name of a project for a given project key.
+     *
+     * @param projectKey the SonarQube project key
+     * @return the project name, or the project key if name is not set
+     * @throws SonarApiException if the API call fails
+     */
+    public String getProjectName(String projectKey) throws SonarApiException {
+        JSONObject component = getProjectInfo(projectKey);
+        return component.optString("name", projectKey);
+    }
+}
diff --git a/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/api/SonarProjectPullRequestsApi.java b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/api/SonarProjectPullRequestsApi.java
new file mode 100644
index 0000000..c849eed
--- /dev/null
+++ b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/api/SonarProjectPullRequestsApi.java
@@ -0,0 +1,69 @@
+/*
+ * Creedengo Dashboard plugin - Provides dashboard to monitor and help reduce the environmental footprint of your programs
+ * Copyright © 2025 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.greencodeinitiative.creedengo.confluence.plugin.sonar.api;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarApiException;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarClient;
+
+/**
+ * Java equivalent of {@code sonar.project-pull-requests.list.api.js}.
+ *
+ * <p>Calls {@code api/project_pull_requests/list} to retrieve pull requests of a project.</p>
+ *
+ * @see <a href="https://docs.sonarsource.com/sonarqube/latest/extension-guide/web-api/#api-project_pull_requests">SonarQube Project Pull Requests API</a>
+ */
+public class SonarProjectPullRequestsApi {
+
+    private static final String ROUTE = "api/project_pull_requests/list";
+
+    private final SonarClient client;
+
+    public SonarProjectPullRequestsApi(SonarClient client) {
+        this.client = client;
+    }
+
+    /**
+     * Get the list of pull requests for a given project.
+     *
+     * @param project the SonarQube project key
+     * @return a list of pull requests as {@link JSONObject}
+     * @throws SonarApiException if the API call fails
+     */
+    public List<JSONObject> getProjectPullRequests(String project) throws SonarApiException {
+        Map<String, String> params = SonarClient.params();
+        params.put("project", project);
+
+        JSONObject response = client.getJSON(ROUTE, params);
+        JSONArray pullRequests = response.optJSONArray("pullRequests");
+
+        List<JSONObject> result = new ArrayList<>();
+        if (pullRequests != null) {
+            for (int i = 0; i < pullRequests.length(); i++) {
+                result.add(pullRequests.getJSONObject(i));
+            }
+        }
+        return result;
+    }
+}
diff --git a/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/api/SonarRulesApi.java b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/api/SonarRulesApi.java
new file mode 100644
index 0000000..82987c0
--- /dev/null
+++ b/apps/confluence-plugin/src/main/java/org/greencodeinitiative/creedengo/confluence/plugin/sonar/api/SonarRulesApi.java
@@ -0,0 +1,112 @@
+/*
+ * Creedengo Dashboard plugin - Provides dashboard to monitor and help reduce the environmental footprint of your programs
+ * Copyright © 2025 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.greencodeinitiative.creedengo.confluence.plugin.sonar.api;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarApiException;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarClient;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarConstants;
+import org.json.JSONArray;
+import org.json.JSONObject;
+
+/**
+ * Java equivalent of {@code sonar.rules.search.api.js} and {@code sonar.rules.show.api.js}.
+ *
+ * <p>Calls {@code api/rules/search} and {@code api/rules/show}.</p>
+ *
+ * @see <a href="https://docs.sonarsource.com/sonarqube/latest/extension-guide/web-api/#api-rules">SonarQube Rules API</a>
+ */
+public class SonarRulesApi {
+
+    private static final String SEARCH_ROUTE = "api/rules/search";
+    private static final String SHOW_ROUTE = "api/rules/show";
+
+    private final SonarClient client;
+
+    public SonarRulesApi(SonarClient client) {
+        this.client = client;
+    }
+
+    /**
+     * Return SonarQube sustainability rules.
+     * Only gathers rules tagged with sustainability tags.
+     *
+     * @param project the SonarQube project key
+     * @param branch  the branch name
+     * @return a list of rules as {@link JSONObject}
+     * @throws SonarApiException if the API call fails
+     */
+    public List<JSONObject> findRules(String project, String branch) throws SonarApiException {
+        Map<String, String> params = SonarClient.params();
+        params.put("tags", SonarConstants.SUSTAINABILITY_TAGS);
+        params.put("componentKeys", project);
+        params.put("branch", branch);
+
+        JSONObject response = client.getJSON(SEARCH_ROUTE, params);
+        JSONArray rules = response.optJSONArray("rules");
+
+        List<JSONObject> result = new ArrayList<>();
+        if (rules != null) {
+            for (int i = 0; i < rules.length(); i++) {
+                result.add(rules.getJSONObject(i));
+            }
+        }
+        return result;
+    }
+
+    /**
+     * Return details about a specific rule.
+     *
+     * @param ruleKey the rule key (e.g. {@code "java:S1234"})
+     * @return the rule details as a {@link JSONObject}
+     * @throws SonarApiException if the API call fails
+     */
+    public JSONObject getRuleDetails(String ruleKey) throws SonarApiException {
+        Map<String, String> params = SonarClient.params();
+        params.put("rule_key", ruleKey);
+
+        JSONObject response = client.getJSON(SHOW_ROUTE, params);
+        return response.getJSONObject("rule");
+    }
+
+    /**
+     * Return SonarQube rules for a specific tag (e.g. {@code "cpu"} or {@code "ram"}).
+     *
+     * @param tag the exact tag to filter on
+     * @return a list of rules as {@link JSONObject}
+     * @throws SonarApiException if the API call fails
+     */
+    public List<JSONObject> findRulesByTag(String tag) throws SonarApiException {
+        Map<String, String> params = SonarClient.params();
+        params.put("tags", tag);
+
+        JSONObject response = client.getJSON(SEARCH_ROUTE, params);
+        JSONArray rules = response.optJSONArray("rules");
+
+        List<JSONObject> result = new ArrayList<>();
+        if (rules != null) {
+            for (int i = 0; i < rules.length(); i++) {
+                result.add(rules.getJSONObject(i));
+            }
+        }
+        return result;
+    }
+}
diff --git a/apps/confluence-plugin/src/main/resources/META-INF/spring/plugin-context.xml b/apps/confluence-plugin/src/main/resources/META-INF/spring/plugin-context.xml
new file mode 100644
index 0000000..ea0b957
--- /dev/null
+++ b/apps/confluence-plugin/src/main/resources/META-INF/spring/plugin-context.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<beans xmlns="http://www.springframework.org/schema/beans"
+       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+       xmlns:atlassian-scanner="http://www.atlassian.com/schema/atlassian-scanner/2"
+       xsi:schemaLocation="http://www.springframework.org/schema/beans
+        http://www.springframework.org/schema/beans/spring-beans.xsd
+        http://www.atlassian.com/schema/atlassian-scanner
+        http://www.atlassian.com/schema/atlassian-scanner/atlassian-scanner.xsd">
+    <atlassian-scanner:scan-indexes/>
+</beans>
diff --git a/apps/confluence-plugin/src/main/resources/atlassian-plugin.xml b/apps/confluence-plugin/src/main/resources/atlassian-plugin.xml
new file mode 100644
index 0000000..263e809
--- /dev/null
+++ b/apps/confluence-plugin/src/main/resources/atlassian-plugin.xml
@@ -0,0 +1,131 @@
+<atlassian-plugin key="${atlassian.plugin.key}" name="${project.name}" plugins-version="2">
+    <plugin-info>
+        <description>${project.description}</description>
+        <version>${project.version}</version>
+        <vendor name="${project.organization.name}" url="${project.organization.url}" />
+        <param name="plugin-icon">images/creedengoPluginIcon.png</param>
+        <param name="plugin-logo">images/creedengoPluginLogo.png</param>
+        <param name="screenshot-1">images/dashboard-widgets_920x450.png</param>
+    </plugin-info>
+
+    <!-- add our i18n resource -->
+    <resource type="i18n" name="i18n" location="creedengo-confluence-plugin"/>
+    <resource key="icons" name="icons/" type="download" location="myplugin/images/icons"/>  
+    
+    <!-- add our web resources -->
+    <web-resource key="creedengo-confluence-plugin-resources" name="creedengo-confluence-plugin Web Resources">
+        <dependency>com.atlassian.auiplugin:ajs</dependency>
+        <resource type="download" name="creedengo-confluence-plugin.css" location="/css/creedengo-confluence-plugin.css"/>
+        <resource type="download" name="creedengo-confluence-plugin.js" location="/js/creedengo-confluence-plugin.js"/>
+        <!-- Contexte pour s'assurer que les ressources sont chargées dans Confluence  -->
+        <context>${atlassian.plugin.key}</context>
+    </web-resource>
+
+
+    <xhtml-macro name="creedengo-dashboard" class="org.greencodeinitiative.creedengo.confluence.plugin.macro.Dashboard" 
+    key='creedengo-dashboard' icon="/download/resources/${atlassian.plugin.key}/icons/MyMacroIcon.png">
+        <label key="dashboard.label"/>
+        <description key="dashboard.desc"/>
+        <category name="external-content"/>
+        <parameters>     
+            <parameter name="sonarqube_url" type="string" required="true">
+                <label key="dashboard.param.sonarqube_url.label"/>
+                <description key="dashboard.param.sonarqube_url.desc"/>
+            </parameter>
+            <parameter name="sonarqube_token" type="string" required="true">
+                <label key="dashboard.param.sonarqube_token.label"/>
+                <description key="dashboard.param.sonarqube_token.desc"/>
+            </parameter>
+            <parameter name="project_key" type="string" required="true">
+                <label key="dashboard.param.project_key.label"/>
+                <description key="dashboard.param.project_key.desc"/>
+            </parameter>
+            <parameter name="branch" type="string" required="false" default="main">
+                <label key="dashboard.param.branch.label"/>
+                <description key="dashboard.param.branch.desc"/>
+            </parameter>
+        </parameters>
+    </xhtml-macro>
+
+    <xhtml-macro name="creedengo-ecoscore" class="org.greencodeinitiative.creedengo.confluence.plugin.macro.EcoScore" 
+    key='creedengo-ecoscore' icon="/download/resources/${atlassian.plugin.key}/icons/creedengo-ecoscore-icon.png">
+        <label key="creedengo-ecoscore.label"/>
+        <description key="creedengo-ecoscore.desc"/>
+        <category name="external-content"/>
+        <parameters>     
+            <parameter name="sonarqube_url" type="string" required="true">
+                <label key="creedengo-ecoscore.param.sonarqube_url.label"/>
+                <description key="creedengo-ecoscore.param.sonarqube_url.desc"/>
+            </parameter>
+            <parameter name="sonarqube_token" type="string" required="true">
+                <label key="creedengo-ecoscore.param.sonarqube_token.label"/>
+                <description key="creedengo-ecoscore.param.sonarqube_token.desc"/>
+            </parameter>
+            <parameter name="project_key" type="string" required="true">
+                <label key="creedengo-ecoscore.param.project_key.label"/>
+                <description key="creedengo-ecoscore.param.project_key.desc"/>
+            </parameter>
+            <parameter name="branch" type="string" required="false" default="main">
+                <label key="creedengo-ecoscore.param.branch.label"/>
+                <description key="creedengo-ecoscore.param.branch.desc"/>
+            </parameter>
+        </parameters>
+    </xhtml-macro>
+
+    <xhtml-macro name="creedengo-priority-rules" class="org.greencodeinitiative.creedengo.confluence.plugin.macro.PriorityRulesMacro"
+    key='creedengo-priority-rules' icon="/download/resources/${atlassian.plugin.key}/icons/MyMacroIcon.png">
+        <label key="priorityrules.label"/>
+        <description key="priorityrules.desc"/>
+        <category name="external-content"/>
+        <parameters>     
+            <parameter name="sonarqube_url" type="string" required="true">
+                <label key="priorityrules.param.sonarqube_url.label"/>
+                <description key="priorityrules.param.sonarqube_url.desc"/>
+            </parameter>
+            <parameter name="sonarqube_token" type="string" required="true">
+                <label key="priorityrules.param.sonarqube_token.label"/>
+                <description key="priorityrules.param.sonarqube_token.desc"/>
+            </parameter>
+            <parameter name="project_key" type="string" required="true">
+                <label key="priorityrules.param.project_key.label"/>
+                <description key="priorityrules.param.project_key.desc"/>
+            </parameter>
+            <parameter name="branch" type="string" required="false" default="main">
+                <label key="priorityrules.param.branch.label"/>
+                <description key="priorityrules.param.branch.desc"/>
+            </parameter>
+        </parameters>
+    </xhtml-macro>
+
+    <xhtml-macro name="creedengo-piechart" class="org.greencodeinitiative.creedengo.confluence.plugin.macro.PieChartMacro"
+    key='creedengo-piechart' icon="/download/resources/${atlassian.plugin.key}/icons/MyMacroIcon.png">
+        <label key="piechart.label"/>
+        <description key="piechart.desc"/>
+        <category name="external-content"/>
+        <parameters>
+            <parameter name="sonarqube_url" type="string" required="true">
+                <label key="piechart.param.sonarqube_url.label"/>
+                <description key="piechart.param.sonarqube_url.desc"/>
+            </parameter>
+            <parameter name="sonarqube_token" type="string" required="true">
+                <label key="piechart.param.sonarqube_token.label"/>
+                <description key="piechart.param.sonarqube_token.desc"/>
+            </parameter>
+            <parameter name="project_key" type="string" required="true">
+                <label key="piechart.param.project_key.label"/>
+                <description key="piechart.param.project_key.desc"/>
+            </parameter>
+            <parameter name="branch" type="string" required="false" default="main">
+                <label key="piechart.param.branch.label"/>
+                <description key="piechart.param.branch.desc"/>
+            </parameter>
+            <parameter name="metric_tag" type="enum" required="false" default="cpu">
+                <label key="piechart.param.metric_tag.label"/>
+                <description key="piechart.param.metric_tag.desc"/>
+                <value name="cpu"/>
+                <value name="ram"/>
+            </parameter>
+        </parameters>
+    </xhtml-macro>
+
+</atlassian-plugin>
\ No newline at end of file
diff --git a/apps/confluence-plugin/src/main/resources/creedengo-confluence-plugin.properties b/apps/confluence-plugin/src/main/resources/creedengo-confluence-plugin.properties
new file mode 100644
index 0000000..f4f7697
--- /dev/null
+++ b/apps/confluence-plugin/src/main/resources/creedengo-confluence-plugin.properties
@@ -0,0 +1,109 @@
+
+# Creedengo Dashboard — Confluence Plugin i18n properties (default: English)
+#
+# Naming convention:
+#   {macroKey}.label                     — Macro display name
+#   {macroKey}.desc                      — Macro description
+#   {macroKey}.param.{paramName}.label   — Parameter label
+#   {macroKey}.param.{paramName}.desc    — Parameter description
+#
+# Macros defined in this file:
+#   ecoscore       — Sustainability EcoScore (A–E rating)
+#   dashboard      — Full sustainability dashboard
+#   priorityrules  — Top priority SonarQube rules
+#   piechart       — Donut chart per metric tag (CPU / RAM)
+
+
+
+# ECOSCORE MACRO
+# Macro label (displayed in the macro browser and as the macro name in the editor)
+creedengo-ecoscore.label=Creedengo ecoscore
+# Macro description
+creedengo-ecoscore.desc=Show a preconfigured sustainability ecoscore for a given SonarQube project.
+# Parameter labels (displayed as field names in the macro editor)
+creedengo-ecoscore.param.sonarqube_url.label=SonarQube URL
+creedengo-ecoscore.param.sonarqube_token.label=SonarQube Token
+creedengo-ecoscore.param.project_key.label=Project Key
+creedengo-ecoscore.param.branch.label=Branch
+# Parameter descriptions (displayed as help text below each field)
+creedengo-ecoscore.param.sonarqube_url.desc=URL of the SonarQube server (e.g. https://sonarqube.example.com)
+creedengo-ecoscore.param.sonarqube_token.desc=Authentication token for the SonarQube server
+creedengo-ecoscore.param.project_key.desc=Key of the SonarQube project to analyze
+creedengo-ecoscore.param.branch.desc=Branch name to analyze (defaults to main)
+# EcoScore i18n labels
+ecoscore.header=EcoScore of project {0}
+ecoscore.header.emptyurl=EcoScore Creedengo! empty sonarqube_url
+ecoscore.subheader=Your eco-design Score is
+
+
+
+# DASHBOARD MACRO
+# Macro label (displayed in the macro browser and as the macro name in the editor)
+dashboard.label=Creedengo Dashboard
+# Macro description
+dashboard.desc=Show a preconfigured sustainability dashboard for a given SonarQube project.
+
+# Parameter labels (displayed as field names in the macro editor)
+dashboard.param.sonarqube_url.label=SonarQube URL
+dashboard.param.sonarqube_token.label=SonarQube Token
+dashboard.param.project_key.label=Project Key
+dashboard.param.branch.label=Branch
+
+# Parameter descriptions (displayed as help text below each field)
+dashboard.param.sonarqube_url.desc=URL of the SonarQube server (e.g. https://sonarqube.example.com)
+dashboard.param.sonarqube_token.desc=Authentication token for the SonarQube server
+dashboard.param.project_key.desc=Key of the SonarQube project to analyze
+dashboard.param.branch.desc=Branch name to analyze (defaults to main)
+
+# PRIORITY RULES MACRO
+# Macro label (displayed in the macro browser and as the macro name in the editor)
+priorityrules.label=Creedengo Priority Rules
+# Macro description
+priorityrules.desc=Show SonarQube rules grouped by priority (severity) for a given project.
+
+# Parameter labels (displayed as field names in the macro editor)
+priorityrules.param.sonarqube_url.label=SonarQube URL
+priorityrules.param.sonarqube_token.label=SonarQube Token
+priorityrules.param.project_key.label=Project Key
+priorityrules.param.branch.label=Branch
+
+# Parameter descriptions (displayed as help text below each field)
+priorityrules.param.sonarqube_url.desc=URL of the SonarQube server (e.g. https://sonarqube.example.com)
+priorityrules.param.sonarqube_token.desc=Authentication token for the SonarQube server
+priorityrules.param.project_key.desc=Key of the SonarQube project to analyze
+priorityrules.param.branch.desc=Branch name to analyze (defaults to main)
+# Priority Rules i18n labels
+priorityrules.header=Top priority of project {0}
+priorityrules.header.emptyurl=Creedengo! empty sonarqube_url
+priorityrules.subheader=Top 3 of eco-design rules
+
+
+# PIECHART MACRO
+# Macro label (displayed in the macro browser and as the macro name in the editor)
+piechart.label=Creedengo PieChart
+# Macro description
+piechart.desc=Show a donut chart of open SonarQube issues grouped by severity for a given metric tag (CPU or RAM).
+
+# Parameter labels (displayed as field names in the macro editor)
+piechart.param.sonarqube_url.label=SonarQube URL
+piechart.param.sonarqube_token.label=SonarQube Token
+piechart.param.project_key.label=Project Key
+piechart.param.branch.label=Branch
+piechart.param.metric_tag.label=Metric Tag
+
+# Parameter descriptions (displayed as help text below each field)
+piechart.param.sonarqube_url.desc=URL of the SonarQube server (e.g. https://sonarqube.example.com)
+piechart.param.sonarqube_token.desc=Authentication token for the SonarQube server
+piechart.param.project_key.desc=Key of the SonarQube project to analyze
+piechart.param.branch.desc=Branch name to analyze (defaults to main)
+piechart.param.metric_tag.desc=Resource metric tag to filter rules and issues (cpu or ram)
+
+# PieChart i18n labels
+piechart.header=Issues {1} for project {0}
+piechart.header.emptyurl=Creedengo PieChart! empty sonarqube_url
+piechart.donut.label=issues
+piechart.legend.critical=Critical / Blocker
+piechart.legend.major=Major
+piechart.legend.minor=Minor / Info
+piechart.legend.optimized=Optimized rules
+piechart.rules.total=Total rules: {0} 
\ No newline at end of file
diff --git a/apps/confluence-plugin/src/main/resources/creedengo-confluence-plugin_fr_FR.properties b/apps/confluence-plugin/src/main/resources/creedengo-confluence-plugin_fr_FR.properties
new file mode 100644
index 0000000..19da9a9
--- /dev/null
+++ b/apps/confluence-plugin/src/main/resources/creedengo-confluence-plugin_fr_FR.properties
@@ -0,0 +1,99 @@
+# Creedengo Dashboard — Confluence Plugin i18n properties (fr_FR)
+#
+# Convention de nommage :
+#   {macroKey}.label                     — Nom d'affichage de la macro
+#   {macroKey}.desc                      — Description de la macro
+#   {macroKey}.param.{paramName}.label   — Libellé du paramètre
+#   {macroKey}.param.{paramName}.desc    — Description du paramètre
+#
+# Macros définies dans ce fichier :
+#   ecoscore       — EcoScore de durabilité (note A–E)
+#   dashboard      — Tableau de bord complet de durabilité
+#   priorityrules  — Règles SonarQube les plus prioritaires
+#   piechart       — Diagramme en donut par tag métrique (CPU / RAM)
+
+# ECOSCORE MACRO
+# Macro label (displayed in the macro browser and as the macro name in the editor)
+creedengo-ecoscore.label=Creedengo ecoscore
+# Macro description
+creedengo-ecoscore.desc=Affiche un écoscore de durabilité préconfiguré pour un projet SonarQube donné.
+# Parameter labels (displayed as field names in the macro editor)
+creedengo-ecoscore.param.sonarqube_url.label=URL SonarQube
+creedengo-ecoscore.param.sonarqube_token.label=Jeton SonarQube
+creedengo-ecoscore.param.project_key.label=Clé du projet
+creedengo-ecoscore.param.branch.label=Branche
+# Parameter descriptions (displayed as help text below each field)
+creedengo-ecoscore.param.sonarqube_url.desc=URL du serveur SonarQube (ex : https://sonarqube.exemple.com)
+creedengo-ecoscore.param.sonarqube_token.desc=Jeton d'authentification pour le serveur SonarQube
+creedengo-ecoscore.param.project_key.desc=Clé du projet SonarQube à analyser
+creedengo-ecoscore.param.branch.desc=Nom de la branche à analyser (par défaut : main)
+# EcoScore i18n labels
+ecoscore.header=EcoScore du projet {0}
+ecoscore.header.emptyurl=EcoScore Creedengo ! URL SonarQube manquante
+ecoscore.subheader=Votre score d'éco-conception est
+
+
+# DASHBOARD MACRO
+dashboard.label=Tableau de bord Creedengo
+dashboard.desc=Affiche un tableau de bord de durabilité préconfiguré pour un projet SonarQube donné.
+
+dashboard.param.sonarqube_url.label=URL SonarQube
+dashboard.param.sonarqube_token.label=Jeton SonarQube
+dashboard.param.project_key.label=Clé du projet
+dashboard.param.branch.label=Branche
+
+dashboard.param.sonarqube_url.desc=URL du serveur SonarQube (ex : https://sonarqube.exemple.com)
+dashboard.param.sonarqube_token.desc=Jeton d'authentification pour le serveur SonarQube
+dashboard.param.project_key.desc=Clé du projet SonarQube à analyser
+dashboard.param.branch.desc=Nom de la branche à analyser (par défaut : main)
+
+
+
+# PRIORITY RULES MACRO
+priorityrules.label=Règles par priorité Creedengo
+priorityrules.desc=Affiche les règles SonarQube groupées par sévérité pour un projet donné.
+
+# Parameter labels (displayed as field names in the macro editor)
+priorityrules.param.sonarqube_url.label=URL SonarQube
+priorityrules.param.sonarqube_token.label=Jeton SonarQube
+priorityrules.param.project_key.label=Clé du projet
+priorityrules.param.branch.label=Branche
+
+# Parameter descriptions (displayed as help text below each field)
+priorityrules.param.sonarqube_url.desc=URL du serveur SonarQube (ex : https://sonarqube.exemple.com)
+priorityrules.param.sonarqube_token.desc=Jeton d'authentification pour le serveur SonarQube
+priorityrules.param.project_key.desc=Clé du projet SonarQube à analyser
+priorityrules.param.branch.desc=Nom de la branche à analyser (par défaut : main)
+# Priority Rules i18n labels
+priorityrules.header=Top priorité du projet {0}
+priorityrules.header.emptyurl=Creedengo ! URL SonarQube manquante
+priorityrules.subheader=Top 3 des règles d'éco-conception
+
+
+# PIECHART MACRO
+piechart.label=Creedengo Diagramme circulaire
+piechart.desc=Affiche un diagramme en donut des problèmes SonarQube ouverts groupés par sévérité pour un tag métrique donné (CPU ou RAM).
+
+# Libellés des paramètres
+piechart.param.sonarqube_url.label=URL SonarQube
+piechart.param.sonarqube_token.label=Jeton SonarQube
+piechart.param.project_key.label=Clé du projet
+piechart.param.branch.label=Branche
+piechart.param.metric_tag.label=Tag métrique
+
+# Descriptions des paramètres
+piechart.param.sonarqube_url.desc=URL du serveur SonarQube (ex : https://sonarqube.exemple.com)
+piechart.param.sonarqube_token.desc=Jeton d'authentification pour le serveur SonarQube
+piechart.param.project_key.desc=Clé du projet SonarQube à analyser
+piechart.param.branch.desc=Nom de la branche à analyser (par défaut : main)
+piechart.param.metric_tag.desc=Tag de ressource pour filtrer les règles et les problèmes (cpu ou ram)
+
+# PieChart i18n labels
+piechart.header=Issues {1} pour le projet {0}
+piechart.header.emptyurl=Creedengo PieChart ! URL SonarQube manquante
+piechart.donut.label=issues
+piechart.legend.critical=Critique / Bloquant
+piechart.legend.major=Majeur
+piechart.legend.minor=Mineur / Info
+piechart.legend.optimized=Règles optimisées
+piechart.rules.total=Règles totales : {0} 
\ No newline at end of file
diff --git a/apps/confluence-plugin/src/main/resources/css/creedengo-confluence-plugin.css b/apps/confluence-plugin/src/main/resources/css/creedengo-confluence-plugin.css
new file mode 100644
index 0000000..e3a86c6
--- /dev/null
+++ b/apps/confluence-plugin/src/main/resources/css/creedengo-confluence-plugin.css
@@ -0,0 +1,484 @@
+.blue h1 {
+    color: blue;
+    border-left: 4px solid blue;
+    padding-left: 10px;
+}
+
+.red h1 {
+    color: red;
+    border-left: 4px solid red;
+    padding-left: 10px;
+}
+
+.green h1 {
+    color: green;
+    border-left: 4px solid green;
+    padding-left: 10px;
+}
+
+/* Conteneur principal du dashboard Creedengo */
+.creedengo-dashboard {
+    border: 1px solid #ddd;
+    border-radius: 8px;
+    padding: 16px;
+    margin: 16px 0;
+    background-color: #f9f9f9;
+    font-family: Arial, sans-serif;
+}
+
+/* Style par défaut pour tous les h1 dans le dashboard */
+.creedengo-dashboard h1 {
+    margin: 0;
+    font-size: 24px;
+    font-weight: bold;
+}
+
+/* Layout 2 colonnes pour les sections du dashboard */
+.creedengo-dashboard-columns {
+    display: flex;
+    gap: 24px;
+    margin-top: 20px;
+}
+
+.creedengo-dashboard-column {
+    flex: 1;
+    min-width: 0; /* Permet aux enfants de flex de respecter leur min-width */
+}
+
+/* ===== Creedengo Score Widget ===== */
+.creedengo-score-widget {
+    background: #ffffff;
+    border: 1px solid #e0e0e0;
+    border-radius: 12px;
+    padding: 24px;
+    margin: 16px 0;
+    max-width: 480px;
+}
+
+.creedengo-score-title {
+    font-size: 18px;
+    font-weight: 600;
+    color: #333;
+    margin: 0 0 16px 0;
+}
+
+/* --- ABCDE bar --- */
+.creedengo-rate-list {
+    position: relative;
+    display: inline-flex;
+    align-items: center;
+    margin: 12px 0 20px 0;
+    padding: 0;
+}
+
+.creedengo-rate-item {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 42px;
+    height: 38px;
+    font-size: 16px;
+    font-weight: bold;
+    color: rgba(255, 255, 255, 0.6);
+    margin: 0;
+    box-sizing: border-box;
+}
+
+/* Individual background colors for each letter */
+.creedengo-rate-bg-a {
+    background: #178c3d;
+    border-radius: 30px 0 0 30px;
+}
+.creedengo-rate-bg-b {
+    background: #85bb2f;
+}
+.creedengo-rate-bg-c {
+    background: #fecb02;
+}
+.creedengo-rate-bg-d {
+    background: #ff8e12;
+}
+.creedengo-rate-bg-e {
+    background: #e30021;
+    border-radius: 0 30px 30px 0;
+}
+
+/* --- Active score badge (circle overlapping the bar) --- */
+.creedengo-rate {
+    position: absolute;
+    top: -8px;
+    width: 54px;
+    height: 54px;
+    border-radius: 50%;
+    border: 4px solid #ffffff;
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    font-size: 26px;
+    color: #ffffff;
+    font-weight: bold;
+    z-index: 2;
+    box-shadow: 0 2px 6px rgba(0, 0, 0, 0.18);
+}
+
+.creedengo-rate strong {
+    font-weight: 800;
+}
+
+/* Position each badge centered over its bar segment */
+.creedengo-rate-a {
+    background: #178c3d;
+    left: -6px;
+}
+.creedengo-rate-b {
+    background: #85bb2f;
+    left: 36px;
+}
+.creedengo-rate-c {
+    background: #fecb02;
+    left: 78px;
+}
+.creedengo-rate-d {
+    background: #ff8e12;
+    left: 120px;
+}
+.creedengo-rate-e {
+    background: #e30021;
+    left: 162px;
+}
+
+/* --- Score text descriptions --- */
+.creedengo-score-texts {
+    margin-top: 12px;
+}
+
+.creedengo-score-label {
+    font-size: 16px;
+    font-weight: 600;
+    color: #333;
+    margin: 0 0 4px 0;
+}
+
+.creedengo-score-desc {
+    font-size: 14px;
+    color: #555;
+    margin: 0 0 4px 0;
+    line-height: 1.5;
+}
+
+.creedengo-score-tips {
+    font-size: 13px;
+    color: #888;
+    margin: 0;
+    line-height: 1.4;
+}
+/* ===== Creedengo Priority Rules Macro ===== */
+.creedengo-priority-macro {
+    background: #ffffff;
+    border: 1px solid #e0e0e0;
+    border-radius: 12px;
+    padding: 20px;
+    margin: 16px 0;
+    font-family: Arial, sans-serif;
+}
+
+.priority-header {
+    margin-bottom: 12px;
+}
+
+.priority-header h1 {
+    font-size: 16px;
+    font-weight: 600;
+    color: #333;
+    margin: 0 0 8px 0;
+}
+
+.priority-header h3 {
+    margin: 0;
+    font-size: 14px;
+    font-weight: 600;
+    color: #333;
+}
+
+.priority-info {
+    text-align: center;
+    padding: 12px;
+    color: #888;
+    font-style: italic;
+    font-size: 13px;
+}
+
+.priority-items {
+    display: flex;
+    flex-direction: column;
+    gap: 10px;
+}
+
+.priority-item {
+    display: flex;
+    align-items: flex-start;
+    gap: 10px;
+    padding: 10px;
+    border-left: 4px solid #ddd;
+    border-radius: 4px;
+    background-color: #fafafa;
+}
+
+/* Severity-based colors */
+.priority-item.severity-blocker {
+    border-left-color: #e30021;
+    background-color: rgba(227, 0, 33, 0.05);
+}
+
+.priority-item.severity-critical {
+    border-left-color: #ff8e12;
+    background-color: rgba(255, 142, 18, 0.05);
+}
+
+.priority-item.severity-major {
+    border-left-color: #fecb02;
+    background-color: rgba(254, 203, 2, 0.05);
+}
+
+.priority-item.severity-minor {
+    border-left-color: #85bb2f;
+    background-color: rgba(133, 187, 47, 0.05);
+}
+
+.priority-item.severity-info {
+    border-left-color: #178c3d;
+    background-color: rgba(23, 140, 61, 0.05);
+}
+
+.priority-rank {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    width: 36px;
+    height: 36px;
+    border-radius: 50%;
+    background-color: #e0e0e0;
+    color: #333;
+    font-weight: bold;
+    font-size: 14px;
+    flex-shrink: 0;
+}
+
+.priority-item.rank-1 .priority-rank {
+    background: linear-gradient(135deg, #e30021 0%, #ff8e12 100%);
+    color: white;
+}
+
+.priority-item.rank-2 .priority-rank {
+    background: linear-gradient(135deg, #ff8e12 0%, #fecb02 100%);
+    color: white;
+}
+
+.priority-item.rank-3 .priority-rank {
+    background: linear-gradient(135deg, #fecb02 0%, #85bb2f 100%);
+    color: white;
+}
+
+.priority-content {
+    flex: 1;
+}
+
+.priority-title {
+    font-size: 13px;
+    font-weight: 600;
+    color: #333;
+    margin: 0 0 4px 0;
+    line-height: 1.3;
+}
+
+.priority-meta {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    font-size: 11px;
+    color: #666;
+    margin: 0 0 4px 0;
+    flex-wrap: wrap;
+}
+
+.rule-key {
+    padding: 1px 4px;
+    border-radius: 2px;
+    font-family: monospace;
+    color: #555;
+    font-size: 10px;
+}
+
+.rule-severity {
+    display: inline-block;
+    padding: 1px 6px;
+    border-radius: 2px;
+    font-weight: 600;
+    font-size: 10px;
+}
+
+.rule-severity.severity-blocker {
+    background-color: rgba(227, 0, 33, 0.15);
+    color: #e30021;
+}
+
+.rule-severity.severity-critical {
+    background-color: rgba(255, 142, 18, 0.15);
+    color: #ff8e12;
+}
+
+.rule-severity.severity-major {
+    background-color: rgba(254, 203, 2, 0.15);
+    color: #e6a601;
+}
+
+.rule-severity.severity-minor {
+    background-color: rgba(133, 187, 47, 0.15);
+    color: #6d8f1f;
+}
+
+.rule-severity.severity-info {
+    background-color: rgba(23, 140, 61, 0.15);
+    color: #178c3d;
+}
+
+.rule-count {
+    background-color: #e8f5e9;
+    color: #2e7d32;
+    padding: 1px 6px;
+    border-radius: 2px;
+    font-weight: 500;
+    font-size: 10px;
+}
+
+.priority-desc {
+    font-size: 12px;
+    color: #555;
+    line-height: 1.4;
+    margin: 4px 0 0 0;
+}
+
+.priority-desc p {
+    margin: 2px 0;
+}
+
+/* ===== Creedengo PieChart (donut) Macro ===== */
+.creedengo-piechart-widget {
+    background: #ffffff;
+    border: 1px solid #e0e0e0;
+    border-radius: 12px;
+    padding: 24px;
+    margin: 16px 0;
+    max-width: 480px;
+    font-family: Arial, sans-serif;
+}
+
+.creedengo-piechart-widget h2 {
+    font-size: 16px;
+    font-weight: 600;
+    color: #333;
+    margin: 0 0 16px 0;
+}
+
+.creedengo-piechart-body {
+    display: flex;
+    align-items: center;
+    gap: 24px;
+}
+
+/* --- Donut --- */
+.creedengo-donut {
+    width: 180px;
+    height: 180px;
+    border-radius: 50%;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    position: relative;
+    flex-shrink: 0;
+}
+
+.creedengo-donut-inner {
+    width: 130px;
+    height: 130px;
+    background: white;
+    border-radius: 50%;
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    justify-content: center;
+    position: absolute;
+}
+
+.creedengo-donut-value {
+    font-size: 38px;
+    font-weight: 600;
+    color: #000;
+    line-height: 1;
+}
+
+.creedengo-donut-label {
+    font-size: 14px;
+    color: #333;
+    margin-top: 2px;
+}
+
+/* --- Legend --- */
+.creedengo-piechart-legend {
+    flex: 1;
+    min-width: 0;
+}
+
+.piechart-tag-badge {
+    display: inline-block;
+    background: #e8f5e9;
+    color: #2e7d32;
+    font-size: 11px;
+    font-weight: 700;
+    padding: 2px 8px;
+    border-radius: 10px;
+    text-transform: uppercase;
+    margin-bottom: 10px;
+    letter-spacing: 0.5px;
+}
+
+.piechart-legend-list {
+    list-style: none;
+    margin: 0 0 10px 0;
+    padding: 0;
+    display: flex;
+    flex-direction: column;
+    gap: 6px;
+}
+
+.piechart-legend-item {
+    display: flex;
+    align-items: center;
+    gap: 8px;
+    font-size: 13px;
+    color: #333;
+}
+
+.piechart-legend-dot {
+    width: 12px;
+    height: 12px;
+    border-radius: 50%;
+    flex-shrink: 0;
+}
+
+.piechart-legend-text {
+    flex: 1;
+}
+
+.piechart-legend-count {
+    font-weight: 600;
+    color: #555;
+}
+
+.piechart-rules-total {
+    font-size: 12px;
+    color: #888;
+    border-top: 1px solid #eee;
+    padding-top: 8px;
+    margin-top: 4px;
+}
\ No newline at end of file
diff --git a/apps/confluence-plugin/src/main/resources/images/creedengo.png b/apps/confluence-plugin/src/main/resources/images/creedengo.png
new file mode 100644
index 0000000..a1d0ceb
Binary files /dev/null and b/apps/confluence-plugin/src/main/resources/images/creedengo.png differ
diff --git a/apps/confluence-plugin/src/main/resources/images/creedengoPluginIcon.png b/apps/confluence-plugin/src/main/resources/images/creedengoPluginIcon.png
new file mode 100644
index 0000000..2f76e86
Binary files /dev/null and b/apps/confluence-plugin/src/main/resources/images/creedengoPluginIcon.png differ
diff --git a/apps/confluence-plugin/src/main/resources/images/creedengoPluginLogo.png b/apps/confluence-plugin/src/main/resources/images/creedengoPluginLogo.png
new file mode 100644
index 0000000..e0896cc
Binary files /dev/null and b/apps/confluence-plugin/src/main/resources/images/creedengoPluginLogo.png differ
diff --git a/apps/confluence-plugin/src/main/resources/images/dashboard-widgets.png b/apps/confluence-plugin/src/main/resources/images/dashboard-widgets.png
new file mode 100644
index 0000000..98a5cee
Binary files /dev/null and b/apps/confluence-plugin/src/main/resources/images/dashboard-widgets.png differ
diff --git a/apps/confluence-plugin/src/main/resources/images/dashboard-widgets_920x450.png b/apps/confluence-plugin/src/main/resources/images/dashboard-widgets_920x450.png
new file mode 100644
index 0000000..c73b2fb
Binary files /dev/null and b/apps/confluence-plugin/src/main/resources/images/dashboard-widgets_920x450.png differ
diff --git a/apps/confluence-plugin/src/main/resources/images/favicon.png b/apps/confluence-plugin/src/main/resources/images/favicon.png
new file mode 100644
index 0000000..941ae15
Binary files /dev/null and b/apps/confluence-plugin/src/main/resources/images/favicon.png differ
diff --git a/apps/confluence-plugin/src/main/resources/images/icons/creedengoScoreMacroIcon.png b/apps/confluence-plugin/src/main/resources/images/icons/creedengoScoreMacroIcon.png
new file mode 100644
index 0000000..a1d0ceb
Binary files /dev/null and b/apps/confluence-plugin/src/main/resources/images/icons/creedengoScoreMacroIcon.png differ
diff --git a/apps/confluence-plugin/src/main/resources/js/creedengo-confluence-plugin.js b/apps/confluence-plugin/src/main/resources/js/creedengo-confluence-plugin.js
new file mode 100644
index 0000000..7b9f72b
--- /dev/null
+++ b/apps/confluence-plugin/src/main/resources/js/creedengo-confluence-plugin.js
@@ -0,0 +1,23 @@
+/*
+ * Creedengo Dashboard plugin - Provides dashboard to monitor and help reduce the environmental footprint of your programs
+ * Copyright © 2025 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+(function () {
+    // Creedengo macros initialization
+    // This file ensures that macro resources are properly loaded in Confluence
+    console.debug("Creedengo plugin resources initialized");
+})();
\ No newline at end of file
diff --git a/apps/confluence-plugin/src/main/resources/myplugin/images/icons/MyMacroIcon.png b/apps/confluence-plugin/src/main/resources/myplugin/images/icons/MyMacroIcon.png
new file mode 100644
index 0000000..a1d0ceb
Binary files /dev/null and b/apps/confluence-plugin/src/main/resources/myplugin/images/icons/MyMacroIcon.png differ
diff --git a/apps/confluence-plugin/src/main/resources/myplugin/images/icons/creedengo-ecoscore-icon.png b/apps/confluence-plugin/src/main/resources/myplugin/images/icons/creedengo-ecoscore-icon.png
new file mode 100644
index 0000000..9ab1a5a
Binary files /dev/null and b/apps/confluence-plugin/src/main/resources/myplugin/images/icons/creedengo-ecoscore-icon.png differ
diff --git a/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/MyComponentWiredTest.java b/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/MyComponentWiredTest.java
new file mode 100644
index 0000000..a2b60a8
--- /dev/null
+++ b/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/MyComponentWiredTest.java
@@ -0,0 +1,25 @@
+package it.org.greencodeinitiative.creedengo.confluence.plugin;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import com.atlassian.plugins.osgi.test.AtlassianPluginsTestRunner;
+import org.greencodeinitiative.creedengo.confluence.plugin.api.MyPluginComponent;
+import com.atlassian.sal.api.ApplicationProperties;
+
+import static org.junit.Assert.assertEquals;
+
+@RunWith(AtlassianPluginsTestRunner.class)
+public class MyComponentWiredTest {
+    private final ApplicationProperties applicationProperties;
+    private final MyPluginComponent myPluginComponent;
+
+    public MyComponentWiredTest(ApplicationProperties applicationProperties, MyPluginComponent myPluginComponent) {
+        this.applicationProperties = applicationProperties;
+        this.myPluginComponent = myPluginComponent;
+    }
+
+    @Test
+    public void testMyName() {
+        assertEquals("names do not match!", "myComponent:" + applicationProperties.getDisplayName(), myPluginComponent.getName());
+    }
+}
\ No newline at end of file
diff --git a/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/score/ScoreServiceIT.java b/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/score/ScoreServiceIT.java
new file mode 100644
index 0000000..4991b51
--- /dev/null
+++ b/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/score/ScoreServiceIT.java
@@ -0,0 +1,219 @@
+package it.org.greencodeinitiative.creedengo.confluence.plugin.score;
+
+import java.io.IOException;
+import java.io.OutputStream;
+import java.net.InetSocketAddress;
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
+
+import com.sun.net.httpserver.HttpExchange;
+import com.sun.net.httpserver.HttpHandler;
+import com.sun.net.httpserver.HttpServer;
+
+import org.greencodeinitiative.creedengo.confluence.plugin.service.ScoreService;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarApiException;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarService;
+import org.junit.AfterClass;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertNull;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+/**
+ * Integration tests for {@link ScoreService}.
+ *
+ * <p>Uses a lightweight embedded HTTP server to simulate different SonarQube
+ * responses and validate that the ABCDE score is calculated correctly.</p>
+ */
+public class ScoreServiceIT {
+
+    private static HttpServer server;
+    private static int port;
+
+    /** The severity facet response currently served by the mock — changed per test scenario. */
+    private static volatile String issuesResponse;
+    /** The measures response currently served by the mock — changed per test scenario. */
+    private static volatile String measuresResponse;
+
+    @BeforeClass
+    public static void startServer() throws IOException {
+        server = HttpServer.create(new InetSocketAddress(0), 0);
+        port = server.getAddress().getPort();
+
+        server.createContext("/api/issues/search", new HttpHandler() {
+            @Override
+            public void handle(HttpExchange exchange) throws IOException {
+                byte[] body = issuesResponse.getBytes(StandardCharsets.UTF_8);
+                exchange.getResponseHeaders().set("Content-Type", "application/json");
+                exchange.sendResponseHeaders(200, body.length);
+                OutputStream os = exchange.getResponseBody();
+                os.write(body);
+                os.close();
+            }
+        });
+
+        server.createContext("/api/measures/component", new HttpHandler() {
+            @Override
+            public void handle(HttpExchange exchange) throws IOException {
+                byte[] body = measuresResponse.getBytes(StandardCharsets.UTF_8);
+                exchange.getResponseHeaders().set("Content-Type", "application/json");
+                exchange.sendResponseHeaders(200, body.length);
+                OutputStream os = exchange.getResponseBody();
+                os.write(body);
+                os.close();
+            }
+        });
+
+        server.setExecutor(null);
+        server.start();
+    }
+
+    @AfterClass
+    public static void stopServer() {
+        if (server != null) {
+            server.stop(0);
+        }
+    }
+
+    // ---- Helper to build a SonarService pointing at our mock ----
+
+    private ScoreService createScoreService() {
+        SonarService sonarService = new SonarService("http://localhost:" + port, "test-token");
+        return new ScoreService(sonarService);
+    }
+
+    // ---- Helper to build mock JSON responses ----
+
+    private static String severityFacetResponse(int info, int minor, int major, int critical, int blocker) {
+        StringBuilder sb = new StringBuilder();
+        sb.append("{\"total\":0,\"issues\":[],\"facets\":[{\"property\":\"severities\",\"values\":[");
+        sb.append("{\"val\":\"INFO\",\"count\":").append(info).append("},");
+        sb.append("{\"val\":\"MINOR\",\"count\":").append(minor).append("},");
+        sb.append("{\"val\":\"MAJOR\",\"count\":").append(major).append("},");
+        sb.append("{\"val\":\"CRITICAL\",\"count\":").append(critical).append("},");
+        sb.append("{\"val\":\"BLOCKER\",\"count\":").append(blocker).append("}");
+        sb.append("]}]}");
+        return sb.toString();
+    }
+
+    private static String nclocResponse(long ncloc) {
+        return "{\"component\":{\"key\":\"p\",\"measures\":[{\"metric\":\"ncloc\",\"value\":\"" + ncloc + "\"}]}}";
+    }
+
+    // ==================== Score A ====================
+
+    @Test
+    public void scoreA_noIssues() throws SonarApiException {
+        issuesResponse = severityFacetResponse(0, 0, 0, 0, 0);
+        measuresResponse = nclocResponse(1000);
+
+        assertEquals("A", createScoreService().calculateProjectScore("p", "main"));
+    }
+
+    // ==================== Score B ====================
+
+    @Test
+    public void scoreB_fewMinorIssues() throws SonarApiException {
+        issuesResponse = severityFacetResponse(2, 3, 0, 0, 0);
+        measuresResponse = nclocResponse(10000);
+
+        assertEquals("B", createScoreService().calculateProjectScore("p", "main"));
+    }
+
+    @Test
+    public void scoreB_singleInfoIssue() throws SonarApiException {
+        issuesResponse = severityFacetResponse(1, 0, 0, 0, 0);
+        measuresResponse = nclocResponse(10000);
+
+        assertEquals("B", createScoreService().calculateProjectScore("p", "main"));
+    }
+
+    // ==================== Score C ====================
+
+    @Test
+    public void scoreC_tenConsolidatedMinors() throws SonarApiException {
+        issuesResponse = severityFacetResponse(5, 5, 0, 0, 0);
+        measuresResponse = nclocResponse(10000);
+
+        assertEquals("C", createScoreService().calculateProjectScore("p", "main"));
+    }
+
+    @Test
+    public void scoreC_oneMajor() throws SonarApiException {
+        issuesResponse = severityFacetResponse(0, 0, 1, 0, 0);
+        measuresResponse = nclocResponse(10000);
+
+        assertEquals("C", createScoreService().calculateProjectScore("p", "main"));
+    }
+
+    // ==================== Score D ====================
+
+    @Test
+    public void scoreD_highMinorRatio() throws SonarApiException {
+        // 80 minors / 1000 lines = 0.08 ratio → D
+        issuesResponse = severityFacetResponse(40, 40, 0, 0, 0);
+        measuresResponse = nclocResponse(1000);
+
+        assertEquals("D", createScoreService().calculateProjectScore("p", "main"));
+    }
+
+    @Test
+    public void scoreD_tenMajors() throws SonarApiException {
+        issuesResponse = severityFacetResponse(0, 0, 10, 0, 0);
+        measuresResponse = nclocResponse(10000);
+
+        assertEquals("D", createScoreService().calculateProjectScore("p", "main"));
+    }
+
+    @Test
+    public void scoreD_oneCritical() throws SonarApiException {
+        issuesResponse = severityFacetResponse(0, 0, 0, 1, 0);
+        measuresResponse = nclocResponse(10000);
+
+        assertEquals("D", createScoreService().calculateProjectScore("p", "main"));
+    }
+
+    // ==================== Score E ====================
+
+    @Test
+    public void scoreE_oneBlocker() throws SonarApiException {
+        issuesResponse = severityFacetResponse(0, 0, 0, 0, 1);
+        measuresResponse = nclocResponse(10000);
+
+        assertEquals("E", createScoreService().calculateProjectScore("p", "main"));
+    }
+
+    @Test
+    public void scoreE_multipleBlockers() throws SonarApiException {
+        issuesResponse = severityFacetResponse(5, 5, 5, 5, 3);
+        measuresResponse = nclocResponse(10000);
+
+        assertEquals("E", createScoreService().calculateProjectScore("p", "main"));
+    }
+
+    // ==================== ScoreTexts ====================
+
+    @Test
+    public void getScoreTexts_returnsTextsForAllScores() {
+        for (String score : new String[]{"A", "B", "C", "D", "E"}) {
+            ScoreService.ScoreTexts texts = ScoreService.getScoreTexts(score);
+            assertNotNull("Texts should exist for score " + score, texts);
+            assertNotNull("Label should not be null for score " + score, texts.getLabel());
+            assertNotNull("Description should not be null for score " + score, texts.getDescription());
+            assertNotNull("Tips should not be null for score " + score, texts.getTips());
+        }
+    }
+
+    @Test
+    public void getScoreTexts_returnsNullForUnknownScore() {
+        assertNull(ScoreService.getScoreTexts("Z"));
+        assertNull(ScoreService.getScoreTexts(null));
+    }
+
+    @Test
+    public void getScoreTexts_scoreAHasExpectedLabel() {
+        ScoreService.ScoreTexts texts = ScoreService.getScoreTexts("A");
+        assertEquals("Your app is fully optimized, congratulations!", texts.getLabel());
+    }
+}
diff --git a/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/sonar/MockSonarServer.java b/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/sonar/MockSonarServer.java
new file mode 100644
index 0000000..e09d93f
--- /dev/null
+++ b/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/sonar/MockSonarServer.java
@@ -0,0 +1,159 @@
+package it.org.greencodeinitiative.creedengo.confluence.plugin.sonar;
+
+import com.sun.net.httpserver.HttpExchange;
+import com.sun.net.httpserver.HttpHandler;
+import com.sun.net.httpserver.HttpServer;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.net.InetSocketAddress;
+import java.nio.charset.StandardCharsets;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+
+/**
+ * Lightweight embedded HTTP server that mocks SonarQube Web API responses.
+ *
+ * <p>Uses {@code com.sun.net.httpserver.HttpServer} (JDK built-in) so no
+ * external dependency is required. Responses are loaded from JSON fixture files
+ * under {@code src/test/resources/fixtures/sonar/}, which were captured from a
+ * real SonarQube instance running the
+ * {@code org.green-code-initiative:creedengo-java-plugin-test-project} project.</p>
+ *
+ * <p>Usage:</p>
+ * <pre>{@code
+ * MockSonarServer server = new MockSonarServer();
+ * server.start();
+ * String baseUrl = server.getBaseUrl(); // http://localhost:<port>
+ * // ... run tests ...
+ * server.stop();
+ * }</pre>
+ */
+public class MockSonarServer {
+
+    private static final String FIXTURES_BASE = "/fixtures/sonar/";
+
+    private HttpServer server;
+    private int port;
+
+    // ---- Fixture loading ----
+
+    /**
+     * Load a JSON fixture file from the classpath.
+     *
+     * @param name file name relative to {@code /fixtures/sonar/} (e.g. {@code "issues-search.json"})
+     * @return the file contents as a UTF-8 string
+     * @throws IllegalStateException if the fixture is not found
+     */
+    public static String loadFixture(String name) {
+        String path = FIXTURES_BASE + name;
+        try (InputStream is = MockSonarServer.class.getResourceAsStream(path)) {
+            Objects.requireNonNull(is, "Fixture not found on classpath: " + path);
+            return new String(is.readAllBytes(), StandardCharsets.UTF_8);
+        } catch (IOException e) {
+            throw new IllegalStateException("Failed to load fixture: " + path, e);
+        }
+    }
+
+    // ---- Cached fixture responses ----
+
+    public static final String ISSUES_SEARCH_RESPONSE       = loadFixture("issues-search.json");
+    public static final String MEASURES_COMPONENT_RESPONSE  = loadFixture("measures-component.json");
+    public static final String PROJECT_BRANCHES_RESPONSE    = loadFixture("project-branches.json");
+    public static final String PROJECT_PULL_REQUESTS_RESPONSE = loadFixture("project-pull-requests.json");
+    public static final String RULES_SEARCH_RESPONSE        = loadFixture("rules-search.json");
+    public static final String RULES_SHOW_RESPONSE          = loadFixture("rules-show.json");
+
+    public static final String ERROR_401_RESPONSE = "{\"errors\":[{\"msg\":\"Not authorized. Analyzing this project requires authentication.\"}]}";
+
+    /**
+     * Start the mock server on a random available port.
+     */
+    public void start() throws IOException {
+        server = HttpServer.create(new InetSocketAddress(0), 0);
+        port = server.getAddress().getPort();
+
+        // api/issues/search
+        server.createContext("/api/issues/search", jsonHandler(ISSUES_SEARCH_RESPONSE));
+
+        // api/measures/component
+        server.createContext("/api/measures/component", jsonHandler(MEASURES_COMPONENT_RESPONSE));
+
+        // api/rules/search
+        server.createContext("/api/rules/search", jsonHandler(RULES_SEARCH_RESPONSE));
+
+        // api/rules/show
+        server.createContext("/api/rules/show", jsonHandler(RULES_SHOW_RESPONSE));
+
+        // api/project_branches/list
+        server.createContext("/api/project_branches/list", jsonHandler(PROJECT_BRANCHES_RESPONSE));
+
+        // api/project_pull_requests/list
+        server.createContext("/api/project_pull_requests/list", jsonHandler(PROJECT_PULL_REQUESTS_RESPONSE));
+
+        // Endpoint to simulate auth failure
+        server.createContext("/api/auth/fail", new HttpHandler() {
+            @Override
+            public void handle(HttpExchange exchange) throws IOException {
+                byte[] body = ERROR_401_RESPONSE.getBytes(StandardCharsets.UTF_8);
+                exchange.getResponseHeaders().set("Content-Type", "application/json");
+                exchange.sendResponseHeaders(401, body.length);
+                OutputStream os = exchange.getResponseBody();
+                os.write(body);
+                os.close();
+            }
+        });
+
+        server.setExecutor(null);
+        server.start();
+    }
+
+    /**
+     * Stop the mock server.
+     */
+    public void stop() {
+        if (server != null) {
+            server.stop(0);
+        }
+    }
+
+    /**
+     * @return the base URL (e.g. {@code http://localhost:54321})
+     */
+    public String getBaseUrl() {
+        return "http://localhost:" + port;
+    }
+
+    /**
+     * Parse query string from a URI.
+     */
+    public static Map<String, String> parseQuery(String query) {
+        Map<String, String> result = new HashMap<>();
+        if (query == null || query.isEmpty()) {
+            return result;
+        }
+        for (String param : query.split("&")) {
+            String[] pair = param.split("=", 2);
+            String key = pair[0];
+            String value = pair.length > 1 ? pair[1] : "";
+            result.put(key, value);
+        }
+        return result;
+    }
+
+    private static HttpHandler jsonHandler(final String responseBody) {
+        return new HttpHandler() {
+            @Override
+            public void handle(HttpExchange exchange) throws IOException {
+                byte[] body = responseBody.getBytes(StandardCharsets.UTF_8);
+                exchange.getResponseHeaders().set("Content-Type", "application/json");
+                exchange.sendResponseHeaders(200, body.length);
+                OutputStream os = exchange.getResponseBody();
+                os.write(body);
+                os.close();
+            }
+        };
+    }
+}
diff --git a/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarClientIT.java b/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarClientIT.java
new file mode 100644
index 0000000..6acd95a
--- /dev/null
+++ b/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarClientIT.java
@@ -0,0 +1,133 @@
+package it.org.greencodeinitiative.creedengo.confluence.plugin.sonar;
+
+import java.util.Map;
+
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarApiException;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarClient;
+import org.json.JSONObject;
+import org.junit.AfterClass;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import static org.junit.Assert.fail;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+/**
+ * Integration tests for {@link SonarClient} using a mock HTTP server.
+ */
+public class SonarClientIT {
+
+    private static MockSonarServer mockServer;
+    private static SonarClient client;
+
+    @BeforeClass
+    public static void startServer() throws Exception {
+        mockServer = new MockSonarServer();
+        mockServer.start();
+        client = new SonarClient(mockServer.getBaseUrl(), "test-token");
+    }
+
+    @AfterClass
+    public static void stopServer() {
+        mockServer.stop();
+    }
+
+    @Test
+    public void getJSON_shouldReturnParsedJsonObject() throws SonarApiException {
+        Map<String, String> params = SonarClient.params();
+        params.put("componentKeys", "my-project");
+        params.put("branch", "main");
+
+        JSONObject response = client.getJSON("api/issues/search", params);
+
+        assertNotNull("Response should not be null", response);
+        assertTrue("Response should contain 'issues'", response.has("issues"));
+        assertEquals(3, response.getJSONArray("issues").length());
+    }
+
+    @Test
+    public void getJSON_shouldSendQueryParams() throws SonarApiException {
+        Map<String, String> params = SonarClient.params();
+        params.put("component", "my-project");
+        params.put("branch", "main");
+        params.put("metricKeys", "ncloc");
+
+        JSONObject response = client.getJSON("api/measures/component", params);
+
+        assertNotNull(response);
+        assertTrue(response.has("component"));
+    }
+
+    @Test
+    public void getJSON_withTrailingSlashBaseUrl_shouldWork() throws SonarApiException {
+        SonarClient clientWithSlash = new SonarClient(mockServer.getBaseUrl() + "/", "test-token");
+
+        JSONObject response = clientWithSlash.getJSON("api/rules/search", SonarClient.params());
+
+        assertNotNull(response);
+        assertTrue(response.has("rules"));
+    }
+
+    @Test
+    public void getJSON_withNullToken_shouldNotSetAuthHeader() throws SonarApiException {
+        SonarClient clientNoAuth = new SonarClient(mockServer.getBaseUrl(), null);
+
+        JSONObject response = clientNoAuth.getJSON("api/rules/search", SonarClient.params());
+
+        assertNotNull(response);
+    }
+
+    @Test
+    public void getJSON_withEmptyToken_shouldNotSetAuthHeader() throws SonarApiException {
+        SonarClient clientNoAuth = new SonarClient(mockServer.getBaseUrl(), "");
+
+        JSONObject response = clientNoAuth.getJSON("api/rules/search", SonarClient.params());
+
+        assertNotNull(response);
+    }
+
+    @Test(expected = SonarApiException.class)
+    public void getJSON_onHttpError_shouldThrowSonarApiException() throws SonarApiException {
+        client.getJSON("api/auth/fail", SonarClient.params());
+    }
+
+    @Test
+    public void getJSON_onHttpError_exceptionContainsStatusCode() {
+        try {
+            client.getJSON("api/auth/fail", SonarClient.params());
+            fail("Should have thrown SonarApiException");
+        } catch (SonarApiException e) {
+            assertTrue("Exception message should contain HTTP 401",
+                    e.getMessage().contains("401"));
+        }
+    }
+
+    @Test(expected = SonarApiException.class)
+    public void getJSON_withUnreachableServer_shouldThrowSonarApiException() throws SonarApiException {
+        SonarClient badClient = new SonarClient("http://localhost:1", "token");
+        badClient.getJSON("api/issues/search", SonarClient.params());
+    }
+
+    @Test
+    public void getJSON_withNullParams_shouldWork() throws SonarApiException {
+        JSONObject response = client.getJSON("api/rules/search", null);
+
+        assertNotNull(response);
+        assertTrue(response.has("rules"));
+    }
+
+    @Test
+    public void getJSON_withEmptyParams_shouldWork() throws SonarApiException {
+        JSONObject response = client.getJSON("api/rules/search", SonarClient.params());
+
+        assertNotNull(response);
+    }
+
+    @Test
+    public void params_shouldReturnMutableMap() {
+        Map<String, String> params = SonarClient.params();
+        params.put("key", "value");
+        assertEquals("value", params.get("key"));
+    }
+}
diff --git a/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarIssuesApiIT.java b/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarIssuesApiIT.java
new file mode 100644
index 0000000..93514ed
--- /dev/null
+++ b/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarIssuesApiIT.java
@@ -0,0 +1,131 @@
+package it.org.greencodeinitiative.creedengo.confluence.plugin.sonar;
+
+import java.util.List;
+import java.util.Map;
+
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarApiException;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarClient;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.api.SonarIssuesApi;
+import org.json.JSONObject;
+import org.junit.AfterClass;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+/**
+ * Integration tests for {@link SonarIssuesApi} using a mock SonarQube server.
+ */
+public class SonarIssuesApiIT {
+
+    private static MockSonarServer mockServer;
+    private static SonarIssuesApi issuesApi;
+
+    @BeforeClass
+    public static void startServer() throws Exception {
+        mockServer = new MockSonarServer();
+        mockServer.start();
+        SonarClient client = new SonarClient(mockServer.getBaseUrl(), "test-token");
+        issuesApi = new SonarIssuesApi(client);
+    }
+
+    @AfterClass
+    public static void stopServer() {
+        mockServer.stop();
+    }
+
+    // ---- findIssues ----
+
+    @Test
+    public void findIssues_shouldReturnListOfIssues() throws SonarApiException {
+        List<JSONObject> issues = issuesApi.findIssues("my-project", "main");
+
+        assertNotNull("Issues list should not be null", issues);
+        assertEquals("Should return 3 issues", 3, issues.size());
+    }
+
+    @Test
+    public void findIssues_firstIssueShouldHaveExpectedFields() throws SonarApiException {
+        List<JSONObject> issues = issuesApi.findIssues("my-project", "main");
+
+        JSONObject first = issues.get(0);
+        assertEquals("6631fe1e-5775-4ca6-bab7-b90e2104f8f8", first.getString("key"));
+        assertEquals("java:S6909", first.getString("rule"));
+        assertEquals("MAJOR", first.getString("severity"));
+        assertEquals("OPEN", first.getString("status"));
+        assertEquals("org.green-code-initiative:creedengo-java-plugin-test-project", first.getString("project"));
+        assertEquals(86, first.getInt("line"));
+    }
+
+    @Test
+    public void findIssues_secondIssueShouldHaveExpectedFields() throws SonarApiException {
+        List<JSONObject> issues = issuesApi.findIssues("my-project", "main");
+
+        JSONObject second = issues.get(1);
+        assertEquals("c316e8eb-977d-442e-82e5-2d2cfbe41685", second.getString("key"));
+        assertEquals("java:S6912", second.getString("rule"));
+        assertEquals("MAJOR", second.getString("severity"));
+        assertEquals("OPEN", second.getString("status"));
+    }
+
+    @Test
+    public void findIssues_issuesShouldContainTags() throws SonarApiException {
+        List<JSONObject> issues = issuesApi.findIssues("my-project", "main");
+
+        JSONObject first = issues.get(0);
+        assertTrue("First issue should have tags", first.has("tags"));
+        assertEquals(2, first.getJSONArray("tags").length());
+    }
+
+    // ---- getIssuesFacet ----
+
+    @Test
+    public void getIssuesFacet_severities_shouldReturnMap() throws SonarApiException {
+        Map<String, Integer> facet = issuesApi.getIssuesFacet("severities", "my-project", "main", null);
+
+        assertNotNull("Facet map should not be null", facet);
+        assertFalse("Facet map should not be empty", facet.isEmpty());
+    }
+
+    @Test
+    public void getIssuesFacet_severities_shouldContainExpectedValues() throws SonarApiException {
+        Map<String, Integer> facet = issuesApi.getIssuesFacet("severities", "my-project", "main", null);
+
+        assertEquals("MAJOR count", Integer.valueOf(19), facet.get("major"));
+        assertEquals("MINOR count", Integer.valueOf(0), facet.get("minor"));
+        assertEquals("CRITICAL count", Integer.valueOf(0), facet.get("critical"));
+    }
+
+    @Test
+    public void getIssuesFacet_severities_keysShouldBeLowercase() throws SonarApiException {
+        Map<String, Integer> facet = issuesApi.getIssuesFacet("severities", "my-project", "main", null);
+
+        for (String key : facet.keySet()) {
+            assertEquals("Key should be lowercase: " + key, key.toLowerCase(), key);
+        }
+    }
+
+    @Test
+    public void getIssuesFacet_types_shouldReturnExpectedValues() throws SonarApiException {
+        Map<String, Integer> facet = issuesApi.getIssuesFacet("types", "my-project", "main", null);
+
+        assertEquals("CODE_SMELL count", Integer.valueOf(19), facet.get("code_smell"));
+        assertEquals("BUG count", Integer.valueOf(0), facet.get("bug"));
+    }
+
+    @Test(expected = SonarApiException.class)
+    public void getIssuesFacet_unknownFacet_shouldThrow() throws SonarApiException {
+        issuesApi.getIssuesFacet("unknown_facet", "my-project", "main", null);
+    }
+
+    @Test
+    public void getIssuesFacet_withSeverityFilter_shouldWork() throws SonarApiException {
+        // The mock always returns the same response, but we verify the call doesn't fail
+        Map<String, Integer> facet = issuesApi.getIssuesFacet("severities", "my-project", "main", "MAJOR");
+
+        assertNotNull(facet);
+        assertFalse(facet.isEmpty());
+    }
+}
diff --git a/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarMeasuresApiIT.java b/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarMeasuresApiIT.java
new file mode 100644
index 0000000..e9a4032
--- /dev/null
+++ b/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarMeasuresApiIT.java
@@ -0,0 +1,46 @@
+package it.org.greencodeinitiative.creedengo.confluence.plugin.sonar;
+
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarApiException;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarClient;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.api.SonarMeasuresApi;
+import org.junit.AfterClass;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+/**
+ * Integration tests for {@link SonarMeasuresApi} using a mock SonarQube server.
+ */
+public class SonarMeasuresApiIT {
+
+    private static MockSonarServer mockServer;
+    private static SonarMeasuresApi measuresApi;
+
+    @BeforeClass
+    public static void startServer() throws Exception {
+        mockServer = new MockSonarServer();
+        mockServer.start();
+        SonarClient client = new SonarClient(mockServer.getBaseUrl(), "test-token");
+        measuresApi = new SonarMeasuresApi(client);
+    }
+
+    @AfterClass
+    public static void stopServer() {
+        mockServer.stop();
+    }
+
+    @Test
+    public void getNumberOfLineOfCode_shouldReturnExpectedValue() throws SonarApiException {
+        long ncloc = measuresApi.getNumberOfLineOfCode("my-project", "main");
+
+        assertEquals("Should return 1853 lines of code", 1853L, ncloc);
+    }
+
+    @Test
+    public void getNumberOfLineOfCode_shouldReturnPositiveValue() throws SonarApiException {
+        long ncloc = measuresApi.getNumberOfLineOfCode("my-project", "main");
+
+        assertTrue("Lines of code should be positive", ncloc > 0);
+    }
+}
diff --git a/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarProjectBranchesApiIT.java b/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarProjectBranchesApiIT.java
new file mode 100644
index 0000000..dd45c8f
--- /dev/null
+++ b/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarProjectBranchesApiIT.java
@@ -0,0 +1,74 @@
+package it.org.greencodeinitiative.creedengo.confluence.plugin.sonar;
+
+import java.util.List;
+
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarApiException;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarClient;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.api.SonarProjectBranchesApi;
+import org.json.JSONObject;
+import org.junit.AfterClass;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+/**
+ * Integration tests for {@link SonarProjectBranchesApi} using a mock SonarQube server.
+ */
+public class SonarProjectBranchesApiIT {
+
+    private static MockSonarServer mockServer;
+    private static SonarProjectBranchesApi branchesApi;
+
+    @BeforeClass
+    public static void startServer() throws Exception {
+        mockServer = new MockSonarServer();
+        mockServer.start();
+        SonarClient client = new SonarClient(mockServer.getBaseUrl(), "test-token");
+        branchesApi = new SonarProjectBranchesApi(client);
+    }
+
+    @AfterClass
+    public static void stopServer() {
+        mockServer.stop();
+    }
+
+    @Test
+    public void getProjectBranches_shouldReturnListOfBranches() throws SonarApiException {
+        List<JSONObject> branches = branchesApi.getProjectBranches("my-project");
+
+        assertNotNull("Branches list should not be null", branches);
+        assertEquals("Should return 2 branches", 2, branches.size());
+    }
+
+    @Test
+    public void getProjectBranches_mainBranchShouldBeFirst() throws SonarApiException {
+        List<JSONObject> branches = branchesApi.getProjectBranches("my-project");
+
+        JSONObject main = branches.get(0);
+        assertEquals("main", main.getString("name"));
+        assertTrue("Main branch isMain should be true", main.getBoolean("isMain"));
+    }
+
+    @Test
+    public void getProjectBranches_developBranchShouldBeSecond() throws SonarApiException {
+        List<JSONObject> branches = branchesApi.getProjectBranches("my-project");
+
+        JSONObject develop = branches.get(1);
+        assertEquals("develop", develop.getString("name"));
+        assertFalse("Develop branch isMain should be false", develop.getBoolean("isMain"));
+    }
+
+    @Test
+    public void getProjectBranches_branchesShouldHaveQualityGateStatus() throws SonarApiException {
+        List<JSONObject> branches = branchesApi.getProjectBranches("my-project");
+
+        for (JSONObject branch : branches) {
+            assertTrue("Branch should have status", branch.has("status"));
+            JSONObject status = branch.getJSONObject("status");
+            assertTrue("Status should have qualityGateStatus", status.has("qualityGateStatus"));
+        }
+    }
+}
diff --git a/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarProjectPullRequestsApiIT.java b/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarProjectPullRequestsApiIT.java
new file mode 100644
index 0000000..d02535c
--- /dev/null
+++ b/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarProjectPullRequestsApiIT.java
@@ -0,0 +1,83 @@
+package it.org.greencodeinitiative.creedengo.confluence.plugin.sonar;
+
+import java.util.List;
+
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarApiException;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarClient;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.api.SonarProjectPullRequestsApi;
+import org.json.JSONObject;
+import org.junit.AfterClass;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+/**
+ * Integration tests for {@link SonarProjectPullRequestsApi} using a mock SonarQube server.
+ */
+public class SonarProjectPullRequestsApiIT {
+
+    private static MockSonarServer mockServer;
+    private static SonarProjectPullRequestsApi pullRequestsApi;
+
+    @BeforeClass
+    public static void startServer() throws Exception {
+        mockServer = new MockSonarServer();
+        mockServer.start();
+        SonarClient client = new SonarClient(mockServer.getBaseUrl(), "test-token");
+        pullRequestsApi = new SonarProjectPullRequestsApi(client);
+    }
+
+    @AfterClass
+    public static void stopServer() {
+        mockServer.stop();
+    }
+
+    @Test
+    public void getProjectPullRequests_shouldReturnListOfPRs() throws SonarApiException {
+        List<JSONObject> prs = pullRequestsApi.getProjectPullRequests("my-project");
+
+        assertNotNull("PR list should not be null", prs);
+        assertEquals("Should return 2 pull requests", 2, prs.size());
+    }
+
+    @Test
+    public void getProjectPullRequests_firstPRShouldHaveCorrectKey() throws SonarApiException {
+        List<JSONObject> prs = pullRequestsApi.getProjectPullRequests("my-project");
+
+        JSONObject pr1 = prs.get(0);
+        assertEquals("42", pr1.getString("key"));
+        assertEquals("Fix sustainability issues", pr1.getString("title"));
+    }
+
+    @Test
+    public void getProjectPullRequests_prsShouldHaveBranchAndBase() throws SonarApiException {
+        List<JSONObject> prs = pullRequestsApi.getProjectPullRequests("my-project");
+
+        for (JSONObject pr : prs) {
+            assertTrue("PR should have branch", pr.has("branch"));
+            assertTrue("PR should have base", pr.has("base"));
+        }
+    }
+
+    @Test
+    public void getProjectPullRequests_prsShouldHaveStatus() throws SonarApiException {
+        List<JSONObject> prs = pullRequestsApi.getProjectPullRequests("my-project");
+
+        for (JSONObject pr : prs) {
+            assertTrue("PR should have status", pr.has("status"));
+            JSONObject status = pr.getJSONObject("status");
+            assertTrue("Status should have qualityGateStatus", status.has("qualityGateStatus"));
+        }
+    }
+
+    @Test
+    public void getProjectPullRequests_secondPRShouldHaveDifferentKey() throws SonarApiException {
+        List<JSONObject> prs = pullRequestsApi.getProjectPullRequests("my-project");
+
+        JSONObject pr2 = prs.get(1);
+        assertEquals("43", pr2.getString("key"));
+        assertEquals("Add ecocode rules", pr2.getString("title"));
+    }
+}
diff --git a/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarRulesApiIT.java b/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarRulesApiIT.java
new file mode 100644
index 0000000..f1f1567
--- /dev/null
+++ b/apps/confluence-plugin/src/test/java/it/org/greencodeinitiative/creedengo/confluence/plugin/sonar/SonarRulesApiIT.java
@@ -0,0 +1,98 @@
+package it.org.greencodeinitiative.creedengo.confluence.plugin.sonar;
+
+import java.util.List;
+
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarApiException;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarClient;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.api.SonarRulesApi;
+import org.json.JSONObject;
+import org.junit.AfterClass;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertTrue;
+import org.junit.BeforeClass;
+import org.junit.Test;
+
+/**
+ * Integration tests for {@link SonarRulesApi} using a mock SonarQube server.
+ */
+public class SonarRulesApiIT {
+
+    private static MockSonarServer mockServer;
+    private static SonarRulesApi rulesApi;
+
+    @BeforeClass
+    public static void startServer() throws Exception {
+        mockServer = new MockSonarServer();
+        mockServer.start();
+        SonarClient client = new SonarClient(mockServer.getBaseUrl(), "test-token");
+        rulesApi = new SonarRulesApi(client);
+    }
+
+    @AfterClass
+    public static void stopServer() {
+        mockServer.stop();
+    }
+
+    // ---- findRules ----
+
+    @Test
+    public void findRules_shouldReturnListOfRules() throws SonarApiException {
+        List<JSONObject> rules = rulesApi.findRules("my-project", "main");
+
+        assertNotNull("Rules list should not be null", rules);
+        assertEquals("Should return 5 rules", 5, rules.size());
+    }
+
+    @Test
+    public void findRules_firstRuleShouldHaveExpectedFields() throws SonarApiException {
+        List<JSONObject> rules = rulesApi.findRules("my-project", "main");
+
+        JSONObject first = rules.get(0);
+        assertEquals("java:S6923", first.getString("key"));
+        assertEquals("Motion Sensor should not use gyroscope", first.getString("name"));
+        assertEquals("MAJOR", first.getString("severity"));
+        assertEquals("java", first.getString("lang"));
+        assertEquals("CODE_SMELL", first.getString("type"));
+    }
+
+    @Test
+    public void findRules_rulesShouldContainSustainabilityTags() throws SonarApiException {
+        List<JSONObject> rules = rulesApi.findRules("my-project", "main");
+
+        JSONObject first = rules.get(0);
+        assertTrue("Rule should have sysTags", first.has("sysTags"));
+        assertTrue("sysTags should contain 'sustainability'",
+                first.getJSONArray("sysTags").toString().contains("sustainability"));
+    }
+
+    // ---- getRuleDetails ----
+
+    @Test
+    public void getRuleDetails_shouldReturnRuleObject() throws SonarApiException {
+        JSONObject rule = rulesApi.getRuleDetails("java:S1234");
+
+        assertNotNull("Rule should not be null", rule);
+    }
+
+    @Test
+    public void getRuleDetails_shouldContainExpectedFields() throws SonarApiException {
+        JSONObject rule = rulesApi.getRuleDetails("java:S1234");
+
+        assertEquals("java:S6923", rule.getString("key"));
+        assertEquals("Motion Sensor should not use gyroscope", rule.getString("name"));
+        assertEquals("MAJOR", rule.getString("severity"));
+        assertEquals("Java", rule.getString("langName"));
+    }
+
+    @Test
+    public void getRuleDetails_shouldContainDescription() throws SonarApiException {
+        JSONObject rule = rulesApi.getRuleDetails("java:S1234");
+
+        // Modern SonarQube uses descriptionSections instead of htmlDesc/mdDesc
+        assertTrue("Rule should have descriptionSections", rule.has("descriptionSections"));
+        assertFalse("descriptionSections should not be empty",
+                rule.getJSONArray("descriptionSections").isEmpty());
+    }
+}
diff --git a/apps/confluence-plugin/src/test/java/ut/org/greencodeinitiative/creedengo/confluence/plugin/MyComponentUnitTest.java b/apps/confluence-plugin/src/test/java/ut/org/greencodeinitiative/creedengo/confluence/plugin/MyComponentUnitTest.java
new file mode 100644
index 0000000..e731b3e
--- /dev/null
+++ b/apps/confluence-plugin/src/test/java/ut/org/greencodeinitiative/creedengo/confluence/plugin/MyComponentUnitTest.java
@@ -0,0 +1,15 @@
+package ut.org.greencodeinitiative.creedengo.confluence.plugin;
+
+import org.junit.Test;
+import org.greencodeinitiative.creedengo.confluence.plugin.api.MyPluginComponent;
+import org.greencodeinitiative.creedengo.confluence.plugin.impl.MyPluginComponentImpl;
+
+import static org.junit.Assert.assertEquals;
+
+public class MyComponentUnitTest {
+    @Test
+    public void testMyName() {
+        MyPluginComponent component = new MyPluginComponentImpl(null);
+        assertEquals("names do not match!", "myComponent", component.getName());
+    }
+}
\ No newline at end of file
diff --git a/apps/confluence-plugin/src/test/java/ut/org/greencodeinitiative/creedengo/confluence/plugin/sonar/api/SonarIssuesApiTests.java b/apps/confluence-plugin/src/test/java/ut/org/greencodeinitiative/creedengo/confluence/plugin/sonar/api/SonarIssuesApiTests.java
new file mode 100644
index 0000000..7766911
--- /dev/null
+++ b/apps/confluence-plugin/src/test/java/ut/org/greencodeinitiative/creedengo/confluence/plugin/sonar/api/SonarIssuesApiTests.java
@@ -0,0 +1,313 @@
+/*
+ * Creedengo Dashboard plugin - Provides dashboard to monitor and help reduce the environmental footprint of your programs
+ * Copyright © 2025 Green Code Initiative (https://green-code-initiative.org)
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package ut.org.greencodeinitiative.creedengo.confluence.plugin.sonar.api;
+
+import java.util.List;
+import java.util.Map;
+
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarApiException;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.SonarClient;
+import org.greencodeinitiative.creedengo.confluence.plugin.sonar.api.SonarIssuesApi;
+import org.json.JSONArray;
+import org.json.JSONObject;
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertNotNull;
+import org.junit.Before;
+import org.junit.Test;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyString;
+import org.mockito.Mock;
+import static org.mockito.Mockito.when;
+import org.mockito.MockitoAnnotations;
+
+/**
+ * Unit tests for {@link SonarIssuesApi}.
+ */
+public class SonarIssuesApiTests {
+
+    @Mock
+    private SonarClient sonarClient;
+
+    private SonarIssuesApi issuesApi;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        issuesApi = new SonarIssuesApi(sonarClient);
+    }
+
+    // ---- findIssues tests ----
+
+    @Test
+    public void testFindIssues_shouldReturnEmptyListWhenNoIssues() throws SonarApiException {
+        // Given
+        JSONObject response = new JSONObject();
+        response.put("issues", new JSONArray());
+        when(sonarClient.getJSON(anyString(), any(Map.class))).thenReturn(response);
+
+        // When
+        List<JSONObject> issues = issuesApi.findIssues("my-project", "main");
+
+        // Then
+        assertNotNull("Issues list should not be null", issues);
+        assertEquals("Should return empty list", 0, issues.size());
+    }
+
+    @Test
+    public void testFindIssues_shouldReturnListOfIssues() throws SonarApiException {
+        // Given
+        JSONArray issuesArray = new JSONArray();
+        JSONObject issue1 = new JSONObject();
+        issue1.put("key", "AYz1234");
+        issue1.put("rule", "java:S1234");
+        issue1.put("severity", "MAJOR");
+        issue1.put("status", "OPEN");
+        issuesArray.put(issue1);
+
+        JSONObject response = new JSONObject();
+        response.put("issues", issuesArray);
+        when(sonarClient.getJSON(anyString(), any(Map.class))).thenReturn(response);
+
+        // When
+        List<JSONObject> issues = issuesApi.findIssues("my-project", "main");
+
+        // Then
+        assertNotNull("Issues list should not be null", issues);
+        assertEquals("Should return 1 issue", 1, issues.size());
+        assertEquals("First issue key should match", "AYz1234", issues.get(0).getString("key"));
+    }
+
+    // ---- getIssuesFacet tests ----
+
+    @Test
+    public void testGetIssuesFacet_shouldReturnFacetCounts() throws SonarApiException {
+        // Given
+        JSONArray facetsArray = new JSONArray();
+        JSONObject facet = new JSONObject();
+        facet.put("property", "severities");
+
+        JSONArray valuesArray = new JSONArray();
+        JSONObject value1 = new JSONObject();
+        value1.put("val", "MAJOR");
+        value1.put("count", 5);
+        JSONObject value2 = new JSONObject();
+        value2.put("val", "MINOR");
+        value2.put("count", 3);
+        valuesArray.put(value1);
+        valuesArray.put(value2);
+
+        facet.put("values", valuesArray);
+        facetsArray.put(facet);
+
+        JSONObject response = new JSONObject();
+        response.put("facets", facetsArray);
+        when(sonarClient.getJSON(anyString(), any(Map.class))).thenReturn(response);
+
+        // When
+        Map<String, Integer> result = issuesApi.getIssuesFacet("severities", "my-project", "main", null);
+
+        // Then
+        assertNotNull("Result should not be null", result);
+        assertEquals("Should have 2 facet values", 2, result.size());
+        assertEquals("MAJOR count should be 5", Integer.valueOf(5), result.get("major"));
+        assertEquals("MINOR count should be 3", Integer.valueOf(3), result.get("minor"));
+    }
+
+    @Test(expected = SonarApiException.class)
+    public void testGetIssuesFacet_shouldThrowExceptionWhenFacetNotFound() throws SonarApiException {
+        // Given
+        JSONObject response = new JSONObject();
+        response.put("facets", new JSONArray());
+        when(sonarClient.getJSON(anyString(), any(Map.class))).thenReturn(response);
+
+        // When
+        issuesApi.getIssuesFacet("types", "my-project", "main", null);
+
+        // Then - exception should be thrown
+    }
+
+    @Test
+    public void testGetIssuesFacet_shouldFilterBySeverityWhenProvided() throws SonarApiException {
+        // Given
+        JSONArray facetsArray = new JSONArray();
+        JSONObject facet = new JSONObject();
+        facet.put("property", "severities");
+
+        JSONArray valuesArray = new JSONArray();
+        JSONObject value = new JSONObject();
+        value.put("val", "BLOCKER");
+        value.put("count", 1);
+        valuesArray.put(value);
+
+        facet.put("values", valuesArray);
+        facetsArray.put(facet);
+
+        JSONObject response = new JSONObject();
+        response.put("facets", facetsArray);
+        when(sonarClient.getJSON(anyString(), any(Map.class))).thenReturn(response);
+
+        // When
+        Map<String, Integer> result = issuesApi.getIssuesFacet("severities", "my-project", "main", "CRITICAL");
+
+        // Then
+        assertNotNull("Result should not be null", result);
+        assertEquals("Should have 1 facet value", 1, result.size());
+        assertEquals("BLOCKER count should be 1", Integer.valueOf(1), result.get("blocker"));
+    }
+
+    // ---- getIssueCountByRuleKey tests ----
+
+    @Test
+    public void testGetIssueCountByRuleKey_shouldReturnRuleKeyCounts() throws SonarApiException {
+        // Given
+        JSONArray facetsArray = new JSONArray();
+        JSONObject facet = new JSONObject();
+        facet.put("property", "rules");
+
+        JSONArray valuesArray = new JSONArray();
+        JSONObject value1 = new JSONObject();
+        value1.put("val", "java:S1234");
+        value1.put("count", 10);
+        JSONObject value2 = new JSONObject();
+        value2.put("val", "java:S5678");
+        value2.put("count", 7);
+        valuesArray.put(value1);
+        valuesArray.put(value2);
+
+        facet.put("values", valuesArray);
+        facetsArray.put(facet);
+
+        JSONObject response = new JSONObject();
+        response.put("facets", facetsArray);
+        when(sonarClient.getJSON(anyString(), any(Map.class))).thenReturn(response);
+
+        // When
+        Map<String, Integer> result = issuesApi.getIssueCountByRuleKey("my-project", "main");
+
+        // Then
+        assertNotNull("Result should not be null", result);
+        assertEquals("Should have 2 rules", 2, result.size());
+        assertEquals("Rule java:S1234 count should be 10", Integer.valueOf(10), result.get("java:S1234"));
+        assertEquals("Rule java:S5678 count should be 7", Integer.valueOf(7), result.get("java:S5678"));
+    }
+
+    @Test
+    public void testGetIssueCountByRuleKey_shouldReturnEmptyMapWhenNoRulesFacet() throws SonarApiException {
+        // Given
+        JSONObject response = new JSONObject();
+        response.put("facets", new JSONArray());
+        when(sonarClient.getJSON(anyString(), any(Map.class))).thenReturn(response);
+
+        // When
+        Map<String, Integer> result = issuesApi.getIssueCountByRuleKey("my-project", "main");
+
+        // Then
+        assertNotNull("Result should not be null", result);
+        assertEquals("Should return empty map", 0, result.size());
+    }
+
+    // ---- getIssuesFacetByTag tests ----
+
+    @Test
+    public void testGetIssuesFacetByTag_shouldReturnFacetCountsForTag() throws SonarApiException {
+        // Given
+        JSONArray facetsArray = new JSONArray();
+        JSONObject facet = new JSONObject();
+        facet.put("property", "severities");
+
+        JSONArray valuesArray = new JSONArray();
+        JSONObject value = new JSONObject();
+        value.put("val", "HIGH");
+        value.put("count", 4);
+        valuesArray.put(value);
+
+        facet.put("values", valuesArray);
+        facetsArray.put(facet);
+
+        JSONObject response = new JSONObject();
+        response.put("facets", facetsArray);
+        when(sonarClient.getJSON(anyString(), any(Map.class))).thenReturn(response);
+
+        // When
+        Map<String, Integer> result = issuesApi.getIssuesFacetByTag("severities", "cpu", "my-project", "main");
+
+        // Then
+        assertNotNull("Result should not be null", result);
+        assertEquals("Should have 1 facet value", 1, result.size());
+        assertEquals("HIGH count should be 4", Integer.valueOf(4), result.get("high"));
+    }
+
+    @Test(expected = SonarApiException.class)
+    public void testGetIssuesFacetByTag_shouldThrowExceptionWhenFacetNotFound() throws SonarApiException {
+        // Given
+        JSONObject response = new JSONObject();
+        response.put("facets", new JSONArray());
+        when(sonarClient.getJSON(anyString(), any(Map.class))).thenReturn(response);
+
+        // When
+        issuesApi.getIssuesFacetByTag("types", "ram", "my-project", "main");
+
+        // Then - exception should be thrown
+    }
+
+    // ---- getIssueCountByRuleKeyByTag tests ----
+
+    @Test
+    public void testGetIssueCountByRuleKeyByTag_shouldReturnRuleKeyCountsForTag() throws SonarApiException {
+        // Given
+        JSONArray facetsArray = new JSONArray();
+        JSONObject facet = new JSONObject();
+        facet.put("property", "rules");
+
+        JSONArray valuesArray = new JSONArray();
+        JSONObject value1 = new JSONObject();
+        value1.put("val", "java:S999");
+        value1.put("count", 6);
+        valuesArray.put(value1);
+
+        facet.put("values", valuesArray);
+        facetsArray.put(facet);
+
+        JSONObject response = new JSONObject();
+        response.put("facets", facetsArray);
+        when(sonarClient.getJSON(anyString(), any(Map.class))).thenReturn(response);
+
+        // When
+        Map<String, Integer> result = issuesApi.getIssueCountByRuleKeyByTag("cpu", "my-project", "main");
+
+        // Then
+        assertNotNull("Result should not be null", result);
+        assertEquals("Should have 1 rule", 1, result.size());
+        assertEquals("Rule java:S999 count should be 6", Integer.valueOf(6), result.get("java:S999"));
+    }
+
+    @Test
+    public void testGetIssueCountByRuleKeyByTag_shouldReturnEmptyMapWhenNoRulesFacet() throws SonarApiException {
+        // Given
+        JSONObject response = new JSONObject();
+        response.put("facets", new JSONArray());
+        when(sonarClient.getJSON(anyString(), any(Map.class))).thenReturn(response);
+
+        // When
+        Map<String, Integer> result = issuesApi.getIssueCountByRuleKeyByTag("cpu", "my-project", "main");
+
+        // Then
+        assertNotNull("Result should not be null", result);
+        assertEquals("Should return empty map", 0, result.size());
+    }
+}
diff --git a/apps/confluence-plugin/src/test/resources/atlassian-plugin.xml b/apps/confluence-plugin/src/test/resources/atlassian-plugin.xml
new file mode 100644
index 0000000..0244c6b
--- /dev/null
+++ b/apps/confluence-plugin/src/test/resources/atlassian-plugin.xml
@@ -0,0 +1,14 @@
+<atlassian-plugin key="${project.groupId}.${project.artifactId}-tests" name="${project.name}" plugins-version="2">
+    <plugin-info>
+        <description>${project.description}</description>
+        <version>${project.version}</version>
+        <vendor name="${project.organization.name}" url="${project.organization.url}" />
+    </plugin-info>
+
+    <!-- from our base plugin -->
+    <component-import key="myComponent" interface="org.greencodeinitiative.creedengo.confluence.plugin.api.MyPluginComponent"/>
+
+    <!-- from the product container -->
+    <component-import key="applicationProperties" interface="com.atlassian.sal.api.ApplicationProperties" />
+    
+</atlassian-plugin>
\ No newline at end of file
diff --git a/apps/confluence-plugin/src/test/resources/fixtures/sonar/issues-search.json b/apps/confluence-plugin/src/test/resources/fixtures/sonar/issues-search.json
new file mode 100644
index 0000000..91a7002
--- /dev/null
+++ b/apps/confluence-plugin/src/test/resources/fixtures/sonar/issues-search.json
@@ -0,0 +1,161 @@
+{
+  "total": 19,
+  "p": 1,
+  "ps": 100,
+  "paging": {
+    "pageIndex": 1,
+    "pageSize": 100,
+    "total": 19
+  },
+  "effortTotal": 95,
+  "issues": [
+    {
+      "key": "6631fe1e-5775-4ca6-bab7-b90e2104f8f8",
+      "rule": "java:S6909",
+      "severity": "MAJOR",
+      "component": "org.green-code-initiative:creedengo-java-plugin-test-project:src/main/java/org/greencodeinitiative/creedengo/java/checks/AvoidSetConstantInBatchUpdateCheck.java",
+      "project": "org.green-code-initiative:creedengo-java-plugin-test-project",
+      "line": 86,
+      "status": "OPEN",
+      "message": "Move this loop-invariant setter invocation out of this loop.",
+      "effort": "5min",
+      "debt": "5min",
+      "tags": [
+        "sustainability",
+        "sql"
+      ],
+      "creationDate": "2025-03-30T23:19:03+0200",
+      "updateDate": "2025-12-02T21:25:26+0100",
+      "type": "CODE_SMELL",
+      "scope": "MAIN",
+      "cleanCodeAttribute": "EFFICIENT",
+      "cleanCodeAttributeCategory": "INTENTIONAL",
+      "impacts": [
+        {
+          "softwareQuality": "MAINTAINABILITY",
+          "severity": "MEDIUM"
+        }
+      ],
+      "issueStatus": "OPEN"
+    },
+    {
+      "key": "c316e8eb-977d-442e-82e5-2d2cfbe41685",
+      "rule": "java:S6912",
+      "severity": "MAJOR",
+      "component": "org.green-code-initiative:creedengo-java-plugin-test-project:src/main/java/org/greencodeinitiative/creedengo/java/checks/AvoidSQLRequestInLoopCheck.java",
+      "project": "org.green-code-initiative:creedengo-java-plugin-test-project",
+      "line": 57,
+      "status": "OPEN",
+      "message": "Use \"addBatch\" and \"executeBatch\" to execute multiple SQL statements in a single call.",
+      "effort": "5min",
+      "debt": "5min",
+      "tags": [
+        "sustainability",
+        "sql"
+      ],
+      "creationDate": "2023-03-17T17:13:02+0100",
+      "updateDate": "2025-12-02T21:25:26+0100",
+      "type": "CODE_SMELL",
+      "scope": "MAIN",
+      "cleanCodeAttribute": "EFFICIENT",
+      "cleanCodeAttributeCategory": "INTENTIONAL",
+      "impacts": [
+        {
+          "softwareQuality": "MAINTAINABILITY",
+          "severity": "MEDIUM"
+        }
+      ],
+      "issueStatus": "OPEN"
+    },
+    {
+      "key": "c910567f-d9cf-49ef-aec6-ec6ad376f42f",
+      "rule": "java:S6905",
+      "severity": "MAJOR",
+      "component": "org.green-code-initiative:creedengo-java-plugin-test-project:src/main/java/org/greencodeinitiative/creedengo/java/checks/AvoidSQLRequestInLoopCheck.java",
+      "project": "org.green-code-initiative:creedengo-java-plugin-test-project",
+      "line": 22,
+      "status": "OPEN",
+      "message": "Don't use the query \"SELECT *\".",
+      "effort": "5min",
+      "debt": "5min",
+      "tags": [
+        "sustainability",
+        "sql"
+      ],
+      "creationDate": "2023-03-09T23:32:36+0100",
+      "updateDate": "2026-02-23T22:39:34+0100",
+      "type": "CODE_SMELL",
+      "scope": "MAIN",
+      "cleanCodeAttribute": "EFFICIENT",
+      "cleanCodeAttributeCategory": "INTENTIONAL",
+      "impacts": [
+        {
+          "softwareQuality": "MAINTAINABILITY",
+          "severity": "MEDIUM"
+        }
+      ],
+      "issueStatus": "OPEN"
+    }
+  ],
+  "components": [
+    {
+      "key": "org.green-code-initiative:creedengo-java-plugin-test-project",
+      "enabled": true,
+      "qualifier": "TRK",
+      "name": "creedengo Java Sonar Plugin Test Project",
+      "longName": "creedengo Java Sonar Plugin Test Project"
+    },
+    {
+      "key": "org.green-code-initiative:creedengo-java-plugin-test-project:src/main/java/org/greencodeinitiative/creedengo/java/checks/AvoidSetConstantInBatchUpdateCheck.java",
+      "enabled": true,
+      "qualifier": "FIL",
+      "name": "AvoidSetConstantInBatchUpdateCheck.java",
+      "longName": "src/main/java/org/greencodeinitiative/creedengo/java/checks/AvoidSetConstantInBatchUpdateCheck.java",
+      "path": "src/main/java/org/greencodeinitiative/creedengo/java/checks/AvoidSetConstantInBatchUpdateCheck.java"
+    }
+  ],
+  "facets": [
+    {
+      "property": "severities",
+      "values": [
+        {
+          "val": "MAJOR",
+          "count": 19
+        },
+        {
+          "val": "INFO",
+          "count": 0
+        },
+        {
+          "val": "MINOR",
+          "count": 0
+        },
+        {
+          "val": "CRITICAL",
+          "count": 0
+        },
+        {
+          "val": "BLOCKER",
+          "count": 0
+        }
+      ]
+    },
+    {
+      "property": "types",
+      "values": [
+        {
+          "val": "CODE_SMELL",
+          "count": 19
+        },
+        {
+          "val": "BUG",
+          "count": 0
+        },
+        {
+          "val": "VULNERABILITY",
+          "count": 0
+        }
+      ]
+    }
+  ]
+}
diff --git a/apps/confluence-plugin/src/test/resources/fixtures/sonar/measures-component.json b/apps/confluence-plugin/src/test/resources/fixtures/sonar/measures-component.json
new file mode 100644
index 0000000..b0b7ec7
--- /dev/null
+++ b/apps/confluence-plugin/src/test/resources/fixtures/sonar/measures-component.json
@@ -0,0 +1,57 @@
+{
+  "component": {
+    "key": "org.green-code-initiative:creedengo-java-plugin-test-project",
+    "name": "creedengo Java Sonar Plugin Test Project",
+    "qualifier": "TRK",
+    "measures": [
+      {
+        "metric": "coverage",
+        "value": "0.0",
+        "bestValue": false
+      },
+      {
+        "metric": "alert_status",
+        "value": "OK"
+      },
+      {
+        "metric": "bugs",
+        "value": "71",
+        "bestValue": false
+      },
+      {
+        "metric": "reliability_rating",
+        "value": "5.0",
+        "bestValue": false
+      },
+      {
+        "metric": "code_smells",
+        "value": "381",
+        "bestValue": false
+      },
+      {
+        "metric": "security_rating",
+        "value": "5.0",
+        "bestValue": false
+      },
+      {
+        "metric": "ncloc",
+        "value": "1853"
+      },
+      {
+        "metric": "vulnerabilities",
+        "value": "9",
+        "bestValue": false
+      },
+      {
+        "metric": "sqale_index",
+        "value": "2213",
+        "bestValue": false
+      },
+      {
+        "metric": "sqale_rating",
+        "value": "1.0",
+        "bestValue": true
+      }
+    ]
+  }
+}
diff --git a/apps/confluence-plugin/src/test/resources/fixtures/sonar/project-branches.json b/apps/confluence-plugin/src/test/resources/fixtures/sonar/project-branches.json
new file mode 100644
index 0000000..633068a
--- /dev/null
+++ b/apps/confluence-plugin/src/test/resources/fixtures/sonar/project-branches.json
@@ -0,0 +1,26 @@
+{
+  "branches": [
+    {
+      "name": "main",
+      "isMain": true,
+      "type": "BRANCH",
+      "status": {
+        "qualityGateStatus": "OK"
+      },
+      "analysisDate": "2025-12-02T21:25:26+0100",
+      "excludedFromPurge": true,
+      "branchId": "c92d890b-79cc-42a8-9048-fe3b15e99c5b"
+    },
+    {
+      "name": "develop",
+      "isMain": false,
+      "type": "BRANCH",
+      "status": {
+        "qualityGateStatus": "OK"
+      },
+      "analysisDate": "2025-12-01T10:00:00+0100",
+      "excludedFromPurge": false,
+      "branchId": "a1b2c3d4-e5f6-7890-abcd-ef1234567890"
+    }
+  ]
+}
diff --git a/apps/confluence-plugin/src/test/resources/fixtures/sonar/project-pull-requests.json b/apps/confluence-plugin/src/test/resources/fixtures/sonar/project-pull-requests.json
new file mode 100644
index 0000000..624dabb
--- /dev/null
+++ b/apps/confluence-plugin/src/test/resources/fixtures/sonar/project-pull-requests.json
@@ -0,0 +1,18 @@
+{
+  "pullRequests": [
+    {
+      "key": "42",
+      "title": "Fix sustainability issues",
+      "branch": "feature/green",
+      "base": "main",
+      "status": {"qualityGateStatus": "OK"}
+    },
+    {
+      "key": "43",
+      "title": "Add ecocode rules",
+      "branch": "feature/eco",
+      "base": "main",
+      "status": {"qualityGateStatus": "ERROR"}
+    }
+  ]
+}
diff --git a/apps/confluence-plugin/src/test/resources/fixtures/sonar/rules-search.json b/apps/confluence-plugin/src/test/resources/fixtures/sonar/rules-search.json
new file mode 100644
index 0000000..5b98e6a
--- /dev/null
+++ b/apps/confluence-plugin/src/test/resources/fixtures/sonar/rules-search.json
@@ -0,0 +1,138 @@
+{
+  "total": 10,
+  "p": 1,
+  "ps": 10,
+  "rules": [
+    {
+      "key": "java:S6923",
+      "repo": "java",
+      "name": "Motion Sensor should not use gyroscope",
+      "severity": "MAJOR",
+      "status": "READY",
+      "tags": [],
+      "sysTags": [
+        "android",
+        "sustainability"
+      ],
+      "lang": "java",
+      "langName": "Java",
+      "type": "CODE_SMELL",
+      "defaultRemFnBaseEffort": "5min",
+      "remFnBaseEffort": "5min",
+      "scope": "MAIN",
+      "cleanCodeAttribute": "CONVENTIONAL",
+      "cleanCodeAttributeCategory": "CONSISTENT",
+      "impacts": [
+        {
+          "softwareQuality": "MAINTAINABILITY",
+          "severity": "MEDIUM"
+        }
+      ]
+    },
+    {
+      "key": "java:S6926",
+      "repo": "java",
+      "name": "Bluetooth should be configured to use low power",
+      "severity": "MAJOR",
+      "status": "READY",
+      "tags": [],
+      "sysTags": [
+        "android",
+        "sustainability"
+      ],
+      "lang": "java",
+      "langName": "Java",
+      "type": "CODE_SMELL",
+      "defaultRemFnBaseEffort": "5min",
+      "remFnBaseEffort": "5min",
+      "scope": "MAIN",
+      "cleanCodeAttribute": "EFFICIENT",
+      "cleanCodeAttributeCategory": "INTENTIONAL",
+      "impacts": [
+        {
+          "softwareQuality": "MAINTAINABILITY",
+          "severity": "MEDIUM"
+        }
+      ]
+    },
+    {
+      "key": "java:S6904",
+      "repo": "java",
+      "name": "Avoid using \"FetchType.EAGER\"",
+      "severity": "MAJOR",
+      "status": "READY",
+      "tags": [],
+      "sysTags": [
+        "jpa",
+        "sustainability",
+        "sql"
+      ],
+      "lang": "java",
+      "langName": "Java",
+      "type": "CODE_SMELL",
+      "defaultRemFnBaseEffort": "10min",
+      "remFnBaseEffort": "10min",
+      "scope": "MAIN",
+      "cleanCodeAttribute": "EFFICIENT",
+      "cleanCodeAttributeCategory": "INTENTIONAL",
+      "impacts": [
+        {
+          "softwareQuality": "MAINTAINABILITY",
+          "severity": "MEDIUM"
+        }
+      ]
+    },
+    {
+      "key": "java:S6905",
+      "repo": "java",
+      "name": "SQL queries should retrieve only necessary fields",
+      "severity": "MAJOR",
+      "status": "READY",
+      "tags": [],
+      "sysTags": [
+        "sustainability",
+        "sql"
+      ],
+      "lang": "java",
+      "langName": "Java",
+      "type": "CODE_SMELL",
+      "defaultRemFnBaseEffort": "5min",
+      "remFnBaseEffort": "5min",
+      "scope": "MAIN",
+      "cleanCodeAttribute": "EFFICIENT",
+      "cleanCodeAttributeCategory": "INTENTIONAL",
+      "impacts": [
+        {
+          "softwareQuality": "MAINTAINABILITY",
+          "severity": "MEDIUM"
+        }
+      ]
+    },
+    {
+      "key": "java:S6909",
+      "repo": "java",
+      "name": "Constant parameters in a \"PreparedStatement\" should not be set more than once",
+      "severity": "MAJOR",
+      "status": "READY",
+      "tags": [],
+      "sysTags": [
+        "sustainability",
+        "sql"
+      ],
+      "lang": "java",
+      "langName": "Java",
+      "type": "CODE_SMELL",
+      "defaultRemFnBaseEffort": "5min",
+      "remFnBaseEffort": "5min",
+      "scope": "MAIN",
+      "cleanCodeAttribute": "EFFICIENT",
+      "cleanCodeAttributeCategory": "INTENTIONAL",
+      "impacts": [
+        {
+          "softwareQuality": "MAINTAINABILITY",
+          "severity": "MEDIUM"
+        }
+      ]
+    }
+  ]
+}
diff --git a/apps/confluence-plugin/src/test/resources/fixtures/sonar/rules-show.json b/apps/confluence-plugin/src/test/resources/fixtures/sonar/rules-show.json
new file mode 100644
index 0000000..2a380a2
--- /dev/null
+++ b/apps/confluence-plugin/src/test/resources/fixtures/sonar/rules-show.json
@@ -0,0 +1,47 @@
+{
+  "rule": {
+    "key": "java:S6923",
+    "repo": "java",
+    "name": "Motion Sensor should not use gyroscope",
+    "severity": "MAJOR",
+    "status": "READY",
+    "tags": [],
+    "sysTags": [
+      "android",
+      "sustainability"
+    ],
+    "lang": "java",
+    "langName": "Java",
+    "type": "CODE_SMELL",
+    "defaultRemFnBaseEffort": "5min",
+    "remFnBaseEffort": "5min",
+    "scope": "MAIN",
+    "cleanCodeAttribute": "CONVENTIONAL",
+    "cleanCodeAttributeCategory": "CONSISTENT",
+    "impacts": [
+      {
+        "softwareQuality": "MAINTAINABILITY",
+        "severity": "MEDIUM"
+      }
+    ],
+    "descriptionSections": [
+      {
+        "key": "resources",
+        "content": "<h3>Documentation</h3>\n<ul>\n  <li> <a href=\"https://source.android.com/docs/core/interaction/sensors/power-use\">Android - Low Power Sensors</a> </li>\n  <li> <a href=\"https://developer.android.com/develop/sensors-and-location/sensors/sensors_motion\">Android - Motion Sensors</a> </li>\n</ul>"
+      },
+      {
+        "key": "how_to_fix",
+        "content": "<p>Replace <code>TYPE_ROTATION_VECTOR</code> with <code>TYPE_GEOMAGNETIC_ROTATION_VECTOR</code> when retrieving the Motion Sensor.</p>\n\n<h4>Noncompliant code example</h4>\n<pre data-diff-id=\"1\" data-diff-type=\"noncompliant\">\npublic class BackGroundActivity extends Activity {\n\n    private Sensor motionSensor;\n\n    @Override\n    protected void onCreate(Bundle savedInstanceState) {\n        SensorManager sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);\n        motionSensor = sensorManager.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR); // Noncompliant\n        // ..\n    }\n    //..\n}\n</pre>\n<h4>Compliant solution</h4>\n<pre data-diff-id=\"1\" data-diff-type=\"compliant\">\npublic class BackGroundActivity extends Activity {\n\n    private Sensor motionSensor;\n\n    @Override\n    protected void onCreate(Bundle savedInstanceState) {\n        SensorManager sensorManager = (SensorManager) getSystemService(Context.SENSOR_SERVICE);\n        motionSensor = sensorManager.getDefaultSensor(Sensor.TYPE_GEOMAGNETIC_ROTATION_VECTOR); // Compliant\n        // ..\n    }\n    //..\n}\n</pre>"
+      },
+      {
+        "key": "root_cause",
+        "content": "<p>The battery life is a major concern for mobile devices and choosing the right Sensor is very important to reduce the power usage and extend the\nbattery life.</p>\n<p>It is recommended, for reducing the power usage, to use <code>TYPE_GEOMAGNETIC_ROTATION_VECTOR</code> for <em>background tasks</em>,\n<em>long-running tasks</em> and other tasks not requiring accurate motion detection.</p>\n<p>The rule reports an issue when <code>android.hardware.SensorManager#getDefaultSensor</code> uses <code>TYPE_ROTATION_VECTOR</code> instead of\n<code>TYPE_GEOMAGNETIC_ROTATION_VECTOR</code>.</p>"
+      },
+      {
+        "key": "introduction",
+        "content": "<p>The <code>android.hardware.SensorManager#getDefaultSensor</code> offers two types of Motion Sensors:</p>\n<ul>\n  <li> <code>TYPE_ROTATION_VECTOR:</code> a combination of the gyroscope, accelerometer, and magnetometer. </li>\n  <li> <code>TYPE_GEOMAGNETIC_ROTATION_VECTOR:</code> a combination of the accelerometer and magnetometer. </li>\n</ul>"
+      }
+    ],
+    "htmlDesc": "<p>The battery life is a major concern for mobile devices and choosing the right Sensor is very important to reduce the power usage and extend the\nbattery life.</p>\n<p>It is recommended, for reducing the power usage, to use <code>TYPE_GEOMAGNETIC_ROTATION_VECTOR</code> for <em>background tasks</em>,\n<em>long-running tasks</em> and other tasks not requiring accurate motion detection.</p>\n<p>The rule reports an issue when <code>android.hardware.SensorManager#getDefaultSensor</code> uses <code>TYPE_ROTATION_VECTOR</code> instead of\n<code>TYPE_GEOMAGNETIC_ROTATION_VECTOR</code>.</p>"
+  }
+}
diff --git a/apps/vscode-sonar-extension/.vscode/tasks.json b/apps/vscode-sonar-extension/.vscode/tasks.json
index e9cbb20..123d580 100644
--- a/apps/vscode-sonar-extension/.vscode/tasks.json
+++ b/apps/vscode-sonar-extension/.vscode/tasks.json
@@ -1,17 +1,53 @@
 {
+  // See https://go.microsoft.com/fwlink/?LinkId=733558
+  // for the documentation about the tasks.json format
+  // these commands will appear in Task > Run Tasks menu.
   "version": "2.0.0",
   "tasks": [
     {
-      "label": "watch",
-      "type": "npm",
-      "script": "watch",
-      "presentation": {
-        "reveal": "never"
-      },
+      "label": "verify",
+      "type": "shell",
+      "command": "mvn -B verify",
+      "group": "build"
+    },
+    {
+      "label": "mvn:test",
+      "type": "shell",
+      "command": "mvn -B test",
+      "group": "test"
+    },
+    {
+      "label": "atlas-debug",
+      "type": "shell",
+      "command": "atlas-debug",
+      "group": "build"
+    },
+    {
+      "label": "atlas-run",
+      "type": "shell",
+      "command": "atlas-run",
+      "group": "build",
+      "problemMatcher": []
+    },
+    {
+      /*
+      * this requires an already-running instance, via atlas-run or atlas-debug
+      * once run, this will repackage the plugin artifact and will be detected.
+      */
+      "label": "quick-reload",
+      "type": "shell",
+      "command": "atlas-mvn package",
       "group": {
         "kind": "build",
         "isDefault": true
-      }
+      },
+      "problemMatcher": []
     },
+    {
+      "label": "atlas test",
+      "type": "shell",
+      "command": "atlas-mvn test",
+      "group": "test"
+    }
   ]
-}
+}
\ No newline at end of file
diff --git a/apps/vue-app/package.json b/apps/vue-app/package.json
index 7e2416d..c813cf5 100644
--- a/apps/vue-app/package.json
+++ b/apps/vue-app/package.json
@@ -32,13 +32,12 @@
     "build-storybook": "storybook build -o docs"
   },
   "dependencies": {
+    "@creedengo/core-services": "workspace: *",
     "@creedengo/sonar-services": "workspace:*",
     "@creedengo/vue-ui": "workspace: *",
     "vue": "^3.5.30"
   },
   "devDependencies": {
-    "@creedengo/core-services": "workspace: *",
-    "@creedengo/sonar-services": "workspace: *",
     "@creedengo/eslint-config": "workspace: *",
     "@creedengo/playwright-config": "workspace:*",
     "@creedengo/vitest-config": "workspace:*",
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 8917132..d421ee4 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -27,6 +27,8 @@ importers:
         specifier: ^2.8.17
         version: 2.8.17
 
+  apps/confluence-plugin: {}
+
   apps/sonar-plugin:
     dependencies:
       '@creedengo/vue-dashboard':
@@ -79,6 +81,9 @@ importers:
 
   apps/vue-app:
     dependencies:
+      '@creedengo/core-services':
+        specifier: 'workspace: *'
+        version: link:../../shared/core-services
       '@creedengo/sonar-services':
         specifier: workspace:*
         version: link:../../shared/sonar-services
@@ -89,9 +94,6 @@ importers:
         specifier: ^3.5.30
         version: 3.5.30(typescript@5.9.3)
     devDependencies:
-      '@creedengo/core-services':
-        specifier: 'workspace: *'
-        version: link:../../shared/core-services
       '@creedengo/eslint-config':
         specifier: 'workspace: *'
         version: link:../../configs/eslint-config
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index cba40af..6c68040 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -1,5 +1,13 @@
 packages:
-- 'apps/*'
-- 'configs/*'
-- 'shared/*'
+  - apps/*
+  - configs/*
+  - shared/*
+
+onlyBuiltDependencies:
+  - '@vscode/vsce-sign'
+  - esbuild
+  - keytar
+  - msw
+  - unrs-resolver
+
 useNodeVersion: 22.17.1