Description:FIELD OF THE INVENTION
The present invention generally relates to removal of dead code in a software repository. More particularly, it relates to a system and method to detect dead code from a repository thereby automatically identifying an unused or obsolete code with high accuracy and remove it safely without breaking the build functionality thereby reducing the technical debt and improving system performance.

BACKGROUND
In any computer system or application, coding forms the core of any software being the language of technology resembling human language to communicate the tasks to be performed by the system. The coding therefore must be precise, concise and succinct. However, the code is usually interrupted by certain sections of code that exists in the software repository but are not executed or used during the program’s runtime, often resulting from outdated features, unreachable code paths or unused variables often referred to as the dead code It serves no purpose and can lead to inefficiencies. The dead code accumulates as software evolves over the time wherein the changes to project requirements, reconstructing of code and the addition of new features often render certain code redundant. Untested codes, test framework, unused functionalities are frequently left behind during upgrades or maintenance, contributing to its buildup. It negatively impacts system performance and maintainability; and increases technical debt by complicating the repository and make it cumbersome for the developers to navigate and understand the relevant sections thereby slowing down the development cycles and increases storage sizes, leading to reduced load times and higher memory usage.
Prior Arts:
US20040128660A1 discloses an efficient dead code elimination method for eliminating dead code from a computer program using an operands graph generated from a flow graph of a computer program, wherein the operands graph is traversed for any unused operands which upon detection of any unused operands enable the instructions defining the unused operands to be removed from execution.
GB2537880A discloses a method and system for identification and removal of redundant code which is directed to management of computer code, and to the identification and removal of redundant code; comprising a main-code base with a set of available deployable units; a loading mechanism to load units; each unit has a corresponding source code deployable unit stored in the main source code-base, where a data processing device monitors the system to create a list with at least one required unit loaded during a time period; and comparing the list to the set of available deployable units to determine if a potentially redundant unit which is part of a set of deployable units but was not loaded during the time period exists; and if such a unit is found, identifying the potentially redundant unit as potentially redundant.
GB2537880A discloses a method for inline function linking general techniques for performing inline dead code elimination, where an apparatus comprising a storage unit stores two source files and a destination file; and the processor copies a first one of the source files to the destination file where this first source file includes a reference to a portion of a second one of the source files, further evaluating the destination file to determine whether the portion of the second source file referenced in the first source file is used by the destination file. Based on the determination that the portion of the second source file referenced in the first source file is used by the destination file, the processor selectively copies the portion of the second source file to the destination file to generate an updated destination file.
Though the available methods enable code elimination, these traditional static analysis tools are inefficient to identify the dead code in large, complex systems with intricate interdependencies. It is therefore evident that there is a lack of specialised tools to extensively address the technical problems enlisted above leaving the developer with challenges in effectively identifying and removing it from software repositories. The proposed system and provides an effective solution thereby identifying dead codes accurately, eliminating them and ensuring smooth functioning of the system.

DEFINITIONS:
The expression “system” used hereinafter in this specification refers to an ecosystem comprising, but not limited to, a code detection and removal system with input and output devices, processing unit, plurality of mobile devices, a mobile device-based application. It is extended to computing systems like mobile phones, laptops, computers, PCs, and other digital computing devices.
The term “input unit” used hereinafter in this specification refers to, but is not limited to, mobile, laptops, computers, PCs, keyboards, mouse, pen drives or drives.
The term “processing unit” refers to the computational hardware or software that performs the database analysis, generation of graphs, detection of dead code, processing, removal of dead code, and like. It includes servers, CPUs, GPUs, or cloud-based systems that handle intensive computations.
The term “output unit” used hereinafter in this specification refers to hardware or digital tools that present processed information to users including, but not limited to computer monitors, mobile screens, printers, or online dashboards.
The term “dead code” also referred as “unreachable code” used hereinafter in this specification refers to a code which is a part of the software repository but is never executed or used under any condition or scenario thereby leading to unnecessary complexity and technical debt.
The term “repositories” used hereinafter in this specification refers to a centralized digital storage that houses share folders, text files, codebases, libraries, and other types of documents, or software components; and has features that allow track code changes easily, simultaneously edit files, and efficiently collaborate on the same task from a remote location as the repositories can be public or private and version-controlled,
The term “crawling” used hereinafter in this specification refers to the automated process of scanning, indexing, and extracting data from various repositories. This process gathers relevant information such as metadata, dependencies, and files for further analysis and processing.
The term “repository crawler” used hereinafter in this specification refers to a component that scans a code repository to analyze its contents, including source code files, configuration files, and dependencies.
The term “database ingestion” used hereinafter in this specification refers to the process of extracting, transforming, and storing data (such as code files and metadata) into a structured database for efficient querying.
The term "Large Language Models" used hereinafter in this specification refers to an advanced computational model employed by the system to perform generic inferencing tasks. The LLMs serve as the core processing engines to identify the intents and attributes of incoming requests and are trained to understand and generate natural language and code, used here to analyze and identify dead code.
The term “graph database” used hereinafter in this specification refers to a database that represents data as nodes which represent entities and edges which represent relationships to efficiently analyze dependencies between functions, files, and references in the code.
The term “rollback mechanism” used hereinafter in this specification refers to a safety feature that reverts changes if the build process fails, ensuring that code modifications do not disrupt the application.
The term “workflow controller” used hereinafter in this specification refers to a component that manages the dead code removal process, tracks progress, and ensures proper execution of each phase.
The term “changelog” used hereinafter in this specification refers to a record of changes made to a codebase, documenting modifications, removals, and updates.
The term “technical debt” used hereinafter in this specification refers to the long-term cost of suboptimal code that increases maintenance effort and reduces software application agility.

OBJECTS OF THE INVENTION:
The primary object of the invention is to provide a system and method to detect dead code from a repository.
Another object of the invention is to provide a system and method that automatically identifies an unused or obsolete code with high accuracy.
Yet another object of the invention is to provide a system and method that removes a dead code safely without breaking the build functionality.
Yet another object of the invention is to provide a system and method that reduces the technical debt and improves system performance.
Yet another object of the invention is to provide a system and method with rollback mechanism for validation which ensures that the code modifications do not disrupt the application.

SUMMARY:
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 discloses a system and method to detect dead code from a repository thereby automatically identifying an unused or obsolete code with high accuracy and remove it safely without breaking the build functionality thereby reducing the technical debt and improving system performance.
The system comprises of an input unit, a processing unit with sequentially arranged modules including a repository crawler, a database, a large language module/s (LLMs), a graph database, a code detection engine, a code removal engine, a build validator, a state machine model and a submission engine that work altogether to employ a workflow for detection and removal of dead codes, and an output unit.
In an aspect of the invention the method employed by the processing unit of the system includes crawling the targeted repository for scanning and extracting all the files from a stored structured database, data ingestion to read the files, feeding the file input to the LLM and converting to a structured file format, further constructing a graphical representation having nodes and the edges, processing and analysing the graphical representation, detecting false positives for identifying dead code, removing and confirming the suspicious candidates by providing a reason, detecting and flagging the unreferenced nodes, marking them as potential dead codes, removing the flagged dead code iteratively, executing the build scripts to check the compilation and linking errors, enabling a rollback mechanism to validate the build, sending a validated build to the static machine model, enabling the state machine model to manage the workflow thereby tracking all the phases in the code removal workflow, maintaining a changelog and rollback checkpoints, finally compiling and committing the updated code back to the repository crawler.
In yet another aspect, the system and method enableing enhanced program efficiency, eliminates unnecessary computations and memory usage, resulting in faster and more efficient program execution, improved maintainability, reduced program size, reduces technical debt and improves system performance.

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.
Fig. 1. illustrates the components of the system for removal of dead code.
Fig. 2. illustrates the sequential arrangement of the various modules of the system of the present invention.
Fig. 3. illustrates a stepwise method of the present system for removing a dead code.

DETAILED DESCRIPTION OF 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 discloses a system and method to detect dead code from a repository thereby automatically identifying an unused or obsolete code with high accuracy and remove it safely without breaking the build functionality thereby reducing the technical debt and improving system performance. As illustrated in Fig.1. and Fig. 2, the system (1) comprises of an input unit (2), a processing unit (3) and output unit (4) wherein the processing unit further comprises of sequentially arranged modules (10) such as, but not limited to repository crawler (11), database (12), large language modules (LLMs) (13), graph database (14), code detection engine (15), code removal engine (16), build validator (17), state machine model (18) and submission engine (19) such that all the modules work altogether to employ a workflow (20) for detection and removal of dead codes in a repository.
In a preferred embodiment of the invention, the various modules (10) of the system works in coherence to each other thereby employing a systematic method (20) to remove the dead code from a repository. The repository crawler (11) is a dedicated component that crawls the targeted repository, and scans all the files including, but not limited to source code, configuration files and/or build scripts. The contents of each file such as its absolute path, filename, and parent directory are stored in a structured database (12) which is also associated with stored metadata including but not limited to last modified time, file size, and file type for future querying and indexing.
In a next embodiment of the invention, the input (5) in form of selected files is sent to a transformer based large language model (LLMs) (13) such as GPT, BERT derivatives, or proprietary models, where the LLMs (13) follow a set of steps to read contents of the files extracted from the database. The LLM (13) using semantic understanding comprehends the meaning of code, including its purpose, references, and relationships; and providing an output (6) in the form of a file type (e.g. .json) such that the file (6) contains the internal and external references, method-level description and purpose, call references indicating invocations, a summary of each method functionality and call hierarchy; wherein the said files give complete relationships and dependencies so as to enable linking other node on which the file is dependent
In yet another embodiment of the invention, the output file (6) is inserted by the LLM (13) into the graph database (14) which constructs a graphical representation (7) having nodes and edges such that the multiples nodes are connected using edges, wherein the “nodes” represent methods, files or folders and the “edges” represent their relationships such as "calls", "defined in", "referenced by".
In a next embodiment of the invention, the code detection engine (15) processes the graphical representations constructed by the graph database (14) using LLMs (13) to detect false positives for identification of the dead code, removing and confirming the suspicious candidates by providing a reason; the code detection engine (15) further detects and flags the nodes without incoming edges thereby marking these nodes as potential dead codes which are tagged to be removed. The code removal engine (16) attempts to remove the flagged dead code iteratively and the changes are made to the codebase and the modifications are saved in stages.
In a next embodiment of the invention, the build validator (17) executes the build scripts after each dead code removal phase, check the compilation and linking errors, and enables a rollback mechanism that validates the build ensuring that the changes can be made if the compilation fails. Once the validation is complete, the state machine model (19) acts as a workflow controller that manages the workflow or method of code removal by managing iterations, compiling status reports and orchestration retries thereby tracking all the phases in the code removal workflow and maintaining a changelog and rollback checkpoints. The code submission engine (19) compiles the final clean code after the dead code is removed successfully and commits the updated code back to the repository crawler (11) thereby enabling the system to remove the dead code accurately and safely without breaking the build functionality finally reducing the technical debt and improving system performance.
In a preferred embodiment of the invention, a method (20) employed by the processing unit (3) for detection and removal of code is disclosed as illustrated in Fig. 3.; where various modules (10) of the system interact seamlessly to execute a workflow comprising the steps as follows:
1. The workflow begins with initiating the system (1).
2. The system (1) initiates the crawl repository (11) crawls the targeted repository scan and extract all the files such as source code, configuration files or build scripts, with its contents including absolute path, filename, and parent directory from a stored structured database (12).
3. The system (1) enables data ingestion where it reads the files from the database (12) associated with stored metadata including last modified time, file size, and file type for future querying and indexing.
4. The system (1) feeds the selected files as input (5) into a transformer based large language model (LLM) (13) where the files are converted to a structured file format (e.g. .json) (6), containing internal and external references.
5. The system (1) then inserts the file (6) into the graph database (14) which constructs a graphical representation (7) having nodes and edges wherein the “nodes” represent methods, files or folders and the “edges” represent their relationships.
6. The system (1) then processes and analyses the graphical representation (7) using the code detection engine (15) that processes and analyses the graph database (14) using LLMs (13) to detect false positives for identification of the dead code, removing and confirming the suspicious candidates by providing a reason.
7. The system (1) further detects and flags the unreferenced nodes using the code detection engine (15) marking these nodes as potential dead codes which are tagged to be removed.
8. The system (1) then removes the flagged dead code iteratively using the code removal engine (16) and the changes are made to the codebase and the modifications are saved in stages.
9. The system (1) then executes the build scripts using a build validator (17) to check the compilation and linking errors.
10. The system (1) enables a rollback mechanism to validate the build using a build validator (17) ensuring that if the build fails the changes can be retried; and where the build is validated it is sent to the static machine model (19).
11. The system (1) enables the state machine model (19) to manage the workflow of code removal by managing iterations, compiling status reports and orchestration retries thereby tracking all the phases in the code removal workflow and maintaining a changelog and rollback checkpoints.
12. The system (1) finally compiles the final code after the dead code is removed successfully using a code submission engine (19) and committing the updated code back to the repository crawler (11) thereby ending the workflow.

Yet another embodiment of the invention enlists the various advantages provided by the system and method of the present invention, such as:
- Enhanced program efficiency; wherein removing dead code eliminates unnecessary computations and memory usage, resulting in faster and more efficient program execution;
- Improved maintainability; whereas the dead code complicates the understanding and maintenance of software systems, elimination of the dead code enables focusing on relevant code, improving code readability, and facilitating future updates and bug fixes.
- Reduced program size; wherein the dead code elimination significantly reduces the size of executable files, optimizing resource usage and improving application distribution;
- Removing a dead code safely without breaking the build functionality;
- Reducing the technical debt and improving system performance;
- Providing a rollback mechanism for validation which ensures that the code modifications do not disrupt the application.
Working Example:
An exemplary scenario is provided that uses the system and method of the present invention to detect and remove the dead code from a repository. In a scenario for “removing dead code in a Node.js repository”, the steps included are as follows:
Step I: Repository crawling-
The system scans a Node.js project repository containing the following files such as- app.js, utils/helper.js., or logger.js, that may contain unused functions.
Step II: Data ingestion-
The system reads and extracts the files from the stored databases or metadata such as:
File Function Last modified References
Logger.js unusedLogger() 01-Mar-2024 None
Helper.js calculateSum() 02-Mar-2024 app.js
Step III: Sematic understanding:
The LLM uses semantic understanding to analyse and comprehend the meaning of code, where the system processes each function and determines its references, thus providing json output from LLM:
[app.js] -- calls --> [calculateSum()]
[helper.js] -- defines --> [calculateSum()]
[logger.js] -- defines --> [unusedLogger()]
Since unusedLogger() has no edges, it is flagged for removal.Since unusedLogger() has no incoming references, it is marked as dead code; and the file is sent to graph database.
Step IV: Graph database representation:
The system inserts the output file from LLM into the graph database thereby constructing a graphical representation where the “nodes” represent methods, files or folders and the “edges” represent their relationships, the LLM detect false positives for identification of the dead code, as follows:
[app.js] -- calls --> [calculateSum()]
[helper.js] -- defines --> [calculateSum()]
[logger.js] -- defines --> [unusedLogger()]
Since unusedLogger() has no edges, it is identified as false positives.
Step V: Flagging the dead code:
Since unusedLogger() has no edges, and identified as false positives by LLMs, the code detection engine flags the unusedLogger() for removal.
Step VI: Removal of flagged code:
The system removes the flagged unused function unusedLogger() from logger.js. using the dead code removal engine.
Step VII: Build and verification:
The system then executes the build scripts using a build validator to check the compilation and linking errors; and enables a rollback mechanism to validate the build ensuring that if the build fails the changes can be retried as follows:
After removal, the system runs the build process (npm run build).
If successful, the cleaned code is committed:
git commit -m "Removed unusedLogger() identified by AI"
If the build fails, changes are rolled back, and the function is restored.
Step VIII: Committing the updated code back to the repository crawler:
The system commits back the updated code without the dead code using the code submission engine, back to the repository crawler thereby completing the workflow, thereby providing a final output as:
✔ unusedLogger() successfully removed
✔ Codebase is cleaner, reducing technical debt
✔ The repository remains functional without breaking dependencies

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:CLAIMS:
We claim,
1. A system and method to detect dead code from a repository; for automatically identifying an unused or obsolete code with high accuracy and remove it safely without breaking the build functionality;
wherein the system (1) comprises of an input unit (2), a processing unit (3) further comprising of sequentially arranged modules (10) including, but not limited to a repository crawler (11), a database (12), a large language module/s (LLMs) (13), a graph database (14), a code detection engine (15), a code removal engine (16), a build validator (17), a state machine model (18) and a submission engine (19) that work altogether to employ a workflow (20) for detection and removal of dead codes in a repository, and an output unit (4);
characterized in that:
the repository crawler (11) crawls the targeted repository and scans all the files including source code, configuration files and/or build scripts; where file contents include absolute path, filename, and parent directory stored in a structured database (12) associated with metadata; the large language model (LLMs) (13) is transformer based, and follow a set of steps to read contents of the files extracted from the database (12) further using semantic understanding to comprehend the meaning of code; and providing an output (6) in the form of a file type (6) containing internal and external references, a method-level description and purpose, call references indicating invocations, a summary of each method functionality and call hierarchy; such that the files (6) give complete relationships and dependencies to enable linking other node on which the file is dependent;
the graph database (14) constructs a graphical representation (7) having nodes and edges based on file (6) where the multiples nodes are connected using edges;
the code detection engine (15) processes the graphical representations (7) constructed by the graph database (14) using LLMs (13) to detect false positives for identification of the dead code, removing and confirming the suspicious candidates further detecting and flagging the nodes without incoming edges thereby marking these nodes as potential dead codes tagged to be removed;
the code removal engine (16) removes the flagged dead code iteratively, the changes are made to the codebase and the modifications are saved in stages,
the build validator (17) executes the build scripts after each dead code removal phase, checks the compilation and linking errors, and enables a rollback mechanism that validates the build ensuring that the changes can be made if the compilation fails;
the state machine model (19) manages the method (20) of code removal by managing iterations, compiling status reports and orchestration retries, thereby tracking all the phases in the code removal workflow and maintaining a changelog and rollback checkpoints;
the code submission engine (19) compiles the final clean code without the dead code and commits the updated code back to the repository crawler (11).

2. The system as claimed in claim 1, wherein the metadata includes, but is not limited to last modified time, file size, and file type for future querying and indexing.

3. The system as claimed in claim 1, wherein the graphical representations (7) comprise of the “nodes” representing methods, files or folders and the “edges” representing their relationships such as "calls", "defined in", "referenced by".

4. The system as claimed in claim 1, wherein system is enabled to remove the dead code accurately and safely without breaking the build functionality finally reducing the technical debt and improving system performance.

5. A method (20) employed by the processing unit (3) for detection and removal of code where the modules (10) interact seamlessly to execute a workflow comprising the steps of;
o initiating the system (1);
o initiating the crawl repository (11) to crawl the targeted repository for scanning and extracting all the files from a stored structured database (12), including source code, configuration files or build scripts, with its contents;
o enabling data ingestion where the system (1) reads the files from the database (12) associated with stored metadata;
o feeding the selected files as input (5) into a transformer based large language model (LLM) (13) where the files are converted to a structured file format (6), containing internal and external references;
o inserting file (6) into the graph database (14) for constructing a graphical representation (7) having “nodes” representing methods, files or folders and the “edges” representing their relationships;
o processing and analysing the graphical representation (7) using the code detection engine (15) that processes and analyses the graph database (14) using LLMs (13) thereby detecting false positives for identification of the dead code, removing and confirming the suspicious candidates by providing a reason;
o detecting and flagging the unreferenced nodes using the code detection engine (15) marking these nodes as potential dead codes which are tagged to be removed;
o removing the flagged dead code iteratively using the code removal engine (16) wherein the changes made to the codebase and the modifications are saved in stages;
o executing the build scripts using a build validator (17) to check the compilation and linking errors;
o enabling a rollback mechanism to validate the build using a build validator (17) ensuring that if the build fails the changes can be retried;
o sending the validated build to the static machine model (19);
o enabling the state machine model (19) to manage the workflow of code removal by managing iterations, compiling status reports and orchestration retries thereby tracking all the phases in the code removal workflow, maintaining a changelog and rollback checkpoints;
o compiling the final code after the dead code is removed successfully using a code submission engine (19);
o committing the updated code back to the repository crawler (11);
o ending the workflow.

6. The method as claimed in claim 5, wherein the rollback mechanism validates the build using a build validator (17) ensuring that where the build fails, the changes can be retried; and where the build is validated, it is sent to the static machine model (19) ensuring that the code modifications do not disrupt the application.

Dated this 11th day of April, 2025.