Description:FIELD OF THE INVENTION
The present invention relates to the field of data processing and analysis systems. More particularly, the present invention specifically relates to system and method that integrate data from diverse sources such as code repositories, program management tools, and collaboration platforms to provide comprehensive activity scoring and complexity evaluation for individuals in organizational environments.
BACKGROUND OF THE INVENTION
Modern organizations operate across multiple tools and platforms for managing code, tracking progress, and collaborating on projects. Evaluating individual contributions and their complexity in such environments remains a challenge due to fragmented data sources and the variability of roles. Existing solutions often fail to dynamically adapt to varying roles, assess code complexity in-depth, or leverage modern AI techniques to score and compare activities accurately. This invention addresses these limitations by introducing a unified system that computes user scores based on diverse metrics and role relevance.
US20210318132A1 discloses various implementations directed to price time priority queue routing for a optimized multi-dimension map matrix tile data exchange linked database are provided. Implementations of various computer methods to organize a multi-dimension map tile data exchange linked database with associated social networking elements and multi dimension coordinate object optimization and price time priority queues and securitization to organize the data and create a fluid system for trading value within the system for the data over a plurality of devices and network members.
US8046313B2 discloses an adaptive interface for a programmable system, for predicting a desired user function, based on user history, as well as machine internal status and context. The apparatus receives an input from the user and other data. A predicted input is presented for confirmation by the user, and the predictive mechanism is updated based on this feedback. Also provided is a pattern recognition system for a multimedia device, wherein a user input is matched to a video stream on a conceptual basis, allowing inexact programming of a multimedia device. The system analyzes a data stream for correspondence with a data pattern for processing and storage.
However, existing methods fail to dynamically adapt to varying roles, assess code complexity in-depth, or leverage modern AI techniques to score and compare activities accurately. There is a need to address these limitations by introducing a unified system that computes user scores based on diverse metrics and role relevance.
OBJECTS OF THE INVENTION
The primary objective of the invention is to provide system and method that integrates data from diverse sources such as code repositories, program management tools, and collaboration platforms to provide comprehensive activity scoring and complexity evaluation for individuals in organizational environments.
Another objective of the invention is to provide a system and method that ingests user-specific activity data and computes scores for code activities, program management contributions, and collaboration efforts.
A further objective of the invention is to provide a system and method that visualizes scores and trends, providing actionable insights for individual and organizational performance evaluation.
SUMMARY OF THE INVENTION
Before the present invention is described, it is to be understood that the present invention is not limited to specific methodologies and materials described, as these may vary as per the person skilled in the art. It is also to be understood that the terminology used in the description is for the purpose of describing the particular embodiments only and is not intended to limit the scope of the present invention.

The present invention describes a system and method that integrates data from multiple tools such as code repositories (e.g., Git), program management tools (e.g., Jira), and collaboration systems (e.g., Slack, Confluence). The system ingests user-specific activity data and computes scores for code activities, program management contributions, and collaboration efforts. Additionally, the system incorporates AI-driven methods such as LLM-based complexity assessment to evaluate changes and reviews in code. A dynamic formula engine allows for role-based adjustments and scoring normalization, ensuring fair comparison across users and roles. The system visualizes scores and trends, providing actionable insights for individual and organizational performance evaluation. The system comprises of data ingestion layer module, data storage layer module, processing and scoring layer module, formula engine module, and visualization layer module. The system will connect to data sources like code repository tool (e.g. git), product management tool (like Jira), collaboration system like confluence, teams, slack etc. The system will then pull data and stores them in a searchable database (e.g. elastic search) The system will have data about users of each system, and work stream associated with the user.
BRIEF DESCRIPTION OF DRAWINGS
A complete understanding of the present invention may be made by reference to the following detailed description which is to be taken in conjugation with the accompanying drawing. The accompanying drawing, which is incorporated into and constitutes a part of the specification, illustrates one or more embodiments of the present invention and, together with the detailed description, it serves to explain the principles and implementations of the invention.
Fig1. illustrates the block diagram of the process of the present invention.

DETAILED DESCRIPTION OF THE INVENTION
Before the present invention is described, it is to be understood that this invention is not limited to methodologies described, as these may vary as per the person skilled in the art. It is also to be understood that the terminology used in the description is for the purpose of describing the particular embodiments only and is not intended to limit the scope of the present invention. Throughout this specification, the word “comprise”, or variations such as “comprises” or “comprising”, will be understood to imply the inclusion of a stated element, integer or step, or group of elements, integers or steps, but not the exclusion of any other element, integer or step, or group of elements, integers or steps. The use of the expression “at least” or “at least one” suggests the use of one or more elements or ingredients or quantities, as the use may be in the embodiment of the invention to achieve one or more of the desired objects or results. Various embodiments of the present invention are described below. It is, however, noted that the present invention is not limited to these embodiments, but rather the intention is that modifications that are apparent are also included.

The present invention describes a system and method that integrates data from multiple tools such as code repositories (e.g., Git), program management tools (e.g., Jira), and collaboration systems (e.g., Slack, Confluence). The system ingests user-specific activity data and computes scores for code activities, program management contributions, and collaboration efforts. Additionally, the system incorporates AI-driven methods such as LLM-based complexity assessment to evaluate changes and reviews in code. A dynamic formula engine allows for role-based adjustments and scoring normalization, ensuring fair comparison across users and roles. The system visualizes scores and trends, providing actionable insights for individual and organizational performance evaluation.

According to the embodiment of the present invention, the system comprises of data ingestion layer module, data storage layer module, processing and scoring layer module, formula engine module, and visualization layer module. The Data Ingestion Layer module connects to multiple tools, including:
- Code repositories (e.g., Git, GitHub, GitLab).
- Program management tools (e.g., Jira, Trello, Azure DevOps).
- Collaboration platforms (e.g., Slack, Teams, Confluence).
This module extracts raw data, including user activities, timestamps, complexity metrics, and workstream associations and normalizes and enriches data for consistency.

The Data Storage Layer module stores ingested data in a searchable database such as Elasticsearch. This module indexes data based on user, activity type, tool, and temporal dimensions and supports efficient queries for user-specific or aggregated metrics.

The Processing and Scoring Layer module utilizes AI-driven analysis for:
- Code complexity evaluation (e.g., cyclomatic complexity).
- Summarizing changes and reviews via a language model (LLM).
- Scoring collaboration activities based on their relevance and impact.
This module computes role-relevant scores across dimensions for Code activities (e.g., changes, reviews), Program management contributions (e.g., issues opened/closed, priorities) and collaboration efforts (e.g., total activities, activity summaries).

The formula engine module is a modular scoring engine that dynamically adjusts parameters such as relevance weights and longevity boosters. This module also supports role-based adjustments, ensuring fairness for developers, QA testers, managers, and other roles.
The visualization Layer module consists of dashboards to display user scores, trends over time, and comparisons across teams. It also consists of heatmaps and charts for identifying high-performing individuals and teams.

According to the embodiment of the present invention, the system will connect to data sources like code repository tool (e.g. git), product management tool (like Jira), collaboration system like confluence, teams, slack etc. The system will then pull data and stores them in a searchable database (e.g. elastic search) The system will have data about users of each system, and work stream associated with the user. The system will get user specific data in the following format:
⁃ Code activities
⁃ Number of changes
⁃ Number of reviews
⁃ Complexity of code repository tool - This will use methods like Cyclomatic complexity. This is computed by using the control flow graph of the program. Cyclomatic complexity measures the number of nested conditions within the code, such as those created by for, if/else, switch, while, and until. The greater the number of conditions, the greater the complexity.
⁃ Complexity of changes done - The code difference is taken out from change and will be send to a LLM model that is tuned for coding. LLM will summarize the change. There will be a method to use that and link it with repository complexity to identify change-complexity.
⁃ Complexity of review done - This is similar to change-complexity but it will be done for review.

According to the embodiment of the present invention, the program management tool activities consists of number of issues opened by the user, number of issues closed by the user, priority and complexity of the issue, number of issues tested (if this is a QA) and number of activities. The collaboration system takes into account total activities and the score of activities. The specific activity is sent to LLM for summary. This is them compared against the complexity of the product and its repository and it will generate a score between 1 and 10. The longevity data consists of getting above data across years and the trends over the years.

According to the embodiment of the present invention, the system uses all the above parameters in a formula engine to put score of the user. The score will be like rate or average to ensure that there is a rationale to compare new employees too who may not have too many records. There is a score against cost, program management, and collaboration. There is a relevance score against each item. For example, a lead may not have code changes. For leads, there can be less relevance of code. The system uses the data to find total score of the user. It puts longevity index as a booster (between 1 and 10%). The system then allows changing the threshold and parameters by updating formula. The final score of all users are compared.

According to the embodiment of the present invention, the input metrics for generating the productivity score consist of code metrics, program management metrics, collaboration metrics, and longevity metrics.
The Code Metrics comprises of Cyclomatic complexity, computed using the control flow graph, Change complexity, derived from LLM summarization and repository complexity, Review complexity, similar to change complexity, Number of changes made by the user and Number of code reviews completed by the user.
The Program Management Metrics comprises of Number of issues opened, Number of issues closed, Priority score of issues, weighted by complexity.
The Collaboration Metrics comprises of Total activities performed by the user, and Activity score, computed via LLM and scaled from 1 to 10.
The Longevity Metrics comprises of Longevity score, based on years of activity and Trends over time, reflecting improvement or decline.

According to the embodiment of the present invention, the parameters for thresholds, weights, and longevity boosters are dynamically adjustable. The system interface allows real-time updates to scoring formulas.
According to the embodiment of the present invention, the applications of the system and method of present invention are:
- Performance evaluations across roles and teams.
- Identification of high-performing individuals and improvement areas.
- Comparative analysis for onboarding new employees.
- Visualization of trends for strategic workforce planning.
Example:
The Code Contribution Score (S_code) is calculated as:
S_code = W_r * [(N_c * C_c + N_c * C_ch + N_r * R_ch) / (1 + Total Code Activities)], wherein (C_c) is Cyclomatic complexity, computed using the control flow graph, (C_ch) is Change complexity, derived from LLM summarization and repository complexity, ( R_ch) is Review complexity, similar to change complexity,( N_c) is Number of changes made by the user and (N_r) is Number of code reviews completed by the user.

The Program Management Score (S_pm) is calculated as:
S_pm = W_r * [(N_io + N_ic) * P / (1 + N_act)], wherein (N_io) Number of issues opened, (N_ic) Number of issues closed, (P) Priority score of issues, weighted by complexity, (N_act) Total activities performed by the user.

The Collaboration Score (S_collab) is calculated as:
S_collab = W_r * [Σ(S_act(i)) / N_act], wherein (N_act) Total activities performed by the user, and (S_act) Activity score, computed via LLM and scaled from 1 to 10.

The Longevity Booster (B_long) is calculated as:
B_long = 1 + (L_y / 10) * T_trend, wherein (L_y) Longevity score, based on years of activity and (T_trend) Trends over time, reflecting improvement or decline

The final Score Computation is as follows:
S_final = B_long * [α * S_code + β * S_pm + γ * S_collab], wherein α, β, γ: Role-specific weights (e.g., developers prioritize α, leads prioritize γ) and α + β + γ = 1 ensures balanced weighting.

The system also allows for role-specific adjustments. For example:
- Developers: High weight on S_code, moderate on S_pm, low on S_collab.
- Testers: Moderate weights across S_code, S_pm, and S_collab.
- Leads/Managers: Low S_code, moderate S_pm, high S_collab.
- Documentation Specialists: Focus on S_collab.

While considerable emphasis has been placed herein on the specific elements of the preferred embodiment, it will be appreciated that many alterations can be made and that many modifications can be made in preferred embodiment without departing from the principles of the invention. These and other changes in the preferred embodiments of the invention will be apparent to those skilled in the art from the disclosure herein, whereby it is to be distinctly understood that the foregoing descriptive matter is to be interpreted merely as illustrative of the invention and not as a limitation.
, Claims:We claim,
1. A system and method to use multi-dimensional user activity and generate productivity score
characterized in that
the system comprises of data ingestion layer module, data storage layer module, processing and scoring layer module, formula engine module, and visualization layer module,
said system integrates data from multiple tools comprising of code repositories, program management tools, and collaboration systems and the system ingests user-specific activity data and computes scores for code activities, program management contributions, and collaboration efforts and the system incorporates AI-driven methods such as LLM-based complexity assessment to evaluate changes and reviews in code and the dynamic formula engine allows for role-based adjustments and scoring normalization, ensuring fair comparison across users and roles,
such that the system visualizes scores and trends, providing actionable insights for individual and organizational performance evaluation;
such that the input metrics for generating the productivity score consist of code metrics, program management metrics, collaboration metrics, and longevity metrics.
2. The system and method as claimed in claim 1, wherein the data ingestion layer module connects to tools, including Code repositories, Program management tools and Collaboration platforms and this module extracts raw data, including user activities, timestamps, complexity metrics, and workstream associations and normalizes and enriches data for consistency.

3. The system and method as claimed in claim 1, wherein the data storage layer module stores ingested data in a searchable database and this module indexes data based on user, activity type, tool, and temporal dimensions and supports efficient queries for user-specific or aggregated metrics.

4. The system and method as claimed in claim 1, wherein the processing and scoring layer module utilizes analysis for code complexity evaluation including cyclomatic complexity, summarizing changes and reviews via a language model and scoring collaboration activities based on their relevance and impact and this module computes role-relevant scores across dimensions for code activities including changes and reviews, program management contributions including issues opened and closed and priorities and collaboration efforts including total activities and activity summaries.

5. The system and method as claimed in claim 1, wherein the formula engine module is a modular scoring engine that dynamically adjusts parameters such as relevance weights and longevity boosters and this module also supports role-based adjustments, ensuring fairness for developers, QA testers, managers, and other roles.

6. The system and method as claimed in claim 1, wherein the visualization layer module consists of dashboards to display user scores, trends over time, and comparisons across teams and also consists of heatmaps and charts for identifying high-performing individuals and teams.

7. The system and method as claimed in claim 1, wherein the system gets user specific data that comprises of code activities, number of changes, number of reviews , complexity of code repository tool by using Cyclomatic complexity and complexity of changes done which is the code difference taken out from change and sent to the LLM model that is tuned for coding which then summarizes the change and complexity of review done.

8. The system and method as claimed in claim 1, wherein the program management tool activities consists of number of issues opened by the user, number of issues closed by the user, priority and complexity of the issue, number of issues tested and number of activities.

9. The system and method as claimed in claim 1, wherein the collaboration system takes into account total activities and the score of activities and the specific activity is sent to LLM for summary which is compared against the complexity of the product and its repository and it generates a score between 1 and 10 and the longevity data consists of data across years and the trends over the years.

10. The system and method as claimed in claim 1, wherein the code metrics comprises of cyclomatic complexity, computed using the control flow graph, change complexity, derived from LLM summarization and repository complexity, review complexity, similar to change complexity, number of changes made by the user and number of code reviews completed by the user; the program management metrics comprises of number of issues opened, number of issues closed, priority score of issues, weighted by complexity; the collaboration metrics comprises of total activities performed by the user, and activity score, computed via LLM and scaled from 1 to 10 and the longevity metrics comprises of longevity score, based on years of activity and trends over time, reflecting improvement or decline.