Description:FIELD OF INVENTION
The present invention relates to software engineering tools. More specifically, it relates to a system and method for cross-project knowledge graph based representations of software development artefacts that enable automated, AI enhanced recommendation of reusable code components and design patterns across multiple projects.
BACKGROUND
A cross-project knowledge graph is a knowledge graph that integrates and connects information from multiple distinct projects or domains. This allows for better understanding of relationships between different projects, improved knowledge discovery and enhanced decision-making across organizational boundaries. Bayesian scoring it combines prior knowledge with observe data to calculate a revised probability, this approach widely used to improve the accuracy of estimates, make predictions and refine decision-making in this field.
Traditional code-reuse libraries (e.g., shared component repositories) store reusable artefacts but lack contextual links to the requirements, tickets, or documentation that gave rise to those artefacts. Issue-tracking and source-control integration tools (e.g., JIRA-Git connectors) expose traceability between individual work items and commits, but these links are project-local and do not scale across an organizational portfolio. Knowledge-graph approaches (e.g., software-component ontologies) have been proposed, yet they typically rely on static, manually-curated schemas and do not incorporate statistical or generative-AI reasoning for reuse recommendation.
PRIOR ART
Indian application No. 202141052560 discloses a system for infusing knowledge graphs and language models (LM) for natural language sentence pair tasks, the system include a processor operatively coupled to an inference engine, the inference engine configured to receive a sentence indicative of a premise and a sentence indicative of a hypothesis, extract LM embeddings for the corresponding sentence, generate a common-sense knowledge graph for corresponding sentence and nodes are derived from the common-sense knowledge graph, assign node importance scores for each of the derived nodes, compute node parameters for the derived nodes, apply an aggregation function to generate pooled values, concatenate the LM embeddings, graph embeddings and pooled values to generate concatenated data and classify the concatenation data to indicate a relationship between the natural language inference pair.

US11507851B2 discloses an artificial intelligence (AI) system that utilizes a machine learning algorithm, such as deep learning, etc. and an application of the AI system is provided. A method, performed by a server, of integrating and managing a plurality of databases (DBs) includes obtaining a plurality of knowledge graphs related to DBs generated from the plurality of DBs having different structures from one another, inputting the plurality of knowledge graphs related to DBs into a learning model related to DB for determining a correlation between data in the plurality of DBs, and obtaining a virtual integrated knowledge graph output from the learning model related to DB and including information about a correlation extracted from the plurality of knowledge graphs related to DB’s.

US9349103B2 discloses a Bayesian belief network (BBN) model is applied to the data set, including for each of a plurality of features of the BBN model, performing an estimate using known observed values associated with remaining features to generate a posterior probability for the corresponding feature. A scoring operation is performed using a predetermined scoring algorithm on posterior probabilities of all of the features to generate a similarity score, wherein the similarity score represents a degree to which a given event represented by the data set is novel relative to historical events represented by the BBN model.

DEFINITIONS
The expression “system” used hereinafter in this specification refers to an ecosystem comprising, but not limited to, system for automatically defining post-deployment success metrics 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 data base 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 “Bayesian scoring” used hereinafter in this specification refers to hardware or digital tools that present probability of a hypothesis as new evidence becomes available. It combines prior knowledge with observed data to produce a more accurate and refined estimate.
The term “Bayesian inference layer” used hereinafter in this specification refers to hardware or digital tools that present a computational layer that uses Bayesian inference to model uncertainty in neural networks.
The term “Fragmented traceability” used hereinafter in this specification refers to hardware or digital tools that present a situation where a product through a supply chain or system is not consistently tracked or documented.
The term “knowledge graph” used hereinafter in this specification refers to hardware or digital tools that present a structured way to represent information as a network of interconnected entities and their relationships.
The term “Generative-AI” used hereinafter in this specification refers to hardware or digital tools that can create new content, including text, images, music, and videos, based on the data it has been trained on.
The term “IDE plugin” used hereinafter in this specification refers to an add-on or extension that is installed inside an Integrated Development Environment (IDE) (like Visual Studio Code, IntelliJ IDEA, PyCharm, Eclipse, etc.) to add extra features or improve the development workflow.

OBJECTS OF THE INVENTION
The primary object of the present invention is to provide a system and method for cross-project knowledge graph based representations for automated reuse recommendation in software development with embedding, Bayesian scoring and LLM-generated adapters.
Another object of the invention is to provide a persistent, multi-project knowledge graph whose nodes represent requirement entities, code-modules entities, ticket entities, documentation entities and release entities.
Yet another object of the inventio is to provide an event-driven ingestion pipelines that automatically extract, normalise and up-sert artefacts from heterogeneous development tools.
Yet another object of the inventio is to provide a graph-based similarity metrics that compute a reuse-relevance score between a target requirement and candidate code modules.
Yet another object of the inventio is to provide a statistical inference layer built on a Bayesian network that learns, from historical data, the probability that a candidate component will be successfully reused given contextual factors.
Yet another object of the invention is to provide a generative AI module that can synthesize missing glue code to make a recommended component fit the target context and suggest modifications to improve compatibility.
Yet another object of the invention is to provide a recommendation engine that fuses the similarity score, Bayesian probability and generative-AI confidence into a composite reuse-score.
Yet another object of the invention is to provide a feedback loop it helps developers to accept, reject or modify recommendations and afterward actions are logged and fed back to the statistical and generative models to improve future predictions.
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 describes a system and method for cross-project knowledge graph based representations for automated reuse recommendation. The system enables enable automated, AI enhanced recommendation of reusable code components and design patterns across multiple projects. the system comprises of an input unit , a processing unit and output unit , wherein the processing unit comprises of multi project knowledge graph module, Event driven ingestion pipelines module, Graph based similarity metrics module, Statistical inference layer module, Generative AI module, Recommendation engine module, Feedback loop module.
According to an aspect of the present invention, the method for cross-project knowledge graph based representations for automated reuse recommendation comprises the steps of: receiving, by a processing system, a recommendation request specifying at least a requirement identifier and a target programming language; fetching, from a graph database, a requirement node corresponding to the requirement identifier; computing, by a graph neural network model, an embedding of the requirement node; querying an approximate nearest neighbor index with the embedding to identify a plurality of candidate code modules;
According to an aspect of the present invention, the method further includes, for each of the candidate code modules: applying a Bayesian network to compute a probability of successful reuse of the candidate code module; constructing a structured prompt including requirement text, an application programming interface, and the target programming language; generating, by a large language model, adapter code for the candidate code module together with a confidence score; performing static analysis on the generated adapter code; executing unit tests in a sandbox environment; assigning a safety score based on whether the unit tests pass or fail; computing a language model confidence value as a function of the confidence score and the safety score; and storing metadata for the candidate code module including a similarity score, the probability of successful reuse, and the language model confidence value.
According to an aspect of the present invention, the method further includes fusing the similarity score, the probability of successful reuse, and the language model confidence value to compute a composite score for each candidate code module; ranking the plurality of candidate code modules based on the composite scores; and outputting a response including at least an identifier of a candidate code module, its composite score, and the generated adapter code.
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 High level system architecture showing data sources, ingestion pipelines, the persistent cross project knowledge graph, statistical inference layer, generative AI module, and recommendation engine.
Fig. 2 Logical schema of the knowledge graph (node types, edge types, example attribute sets).
Fig. 3 Flow diagram of the event driven ingestion process (change detection → parsing → entity creation → upsert).
Fig. 4 Example of graph embedding generation and similarity calculation between a new requirement node and existing code module nodes.
Fig. 5 Bayesian network structure used for reuse success probability estimation (variables: Domain, Language, ComponentComplexity, HistoricalReuseRate, DefectLikelihood).
Fig. 6 Interaction sequence between IDE plug in, recommendation engine, and generative AI when a developer requests reuse suggestions for a user story.
Fig. 7 Feedback loop reinforcement diagram (accept/reject → model update).
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 describes a system and method for knowledge graph based representations of software development artefacts that enable automated, AI enhanced recommendation of reusable code components and design patterns across multiple projects. The system provides a persistent, automatically maintained, cross project knowledge graph combined with statistical inference and generative AI to deliver high quality reuse recommendations.
According to the embodiment of the present invention, as described in FIG. 1, the system comprises of an input unit , a processing unit and output unit , wherein the processing unit further comprises of multi project knowledge graph module, Event driven ingestion pipelines module, Graph based similarity metrics module, Statistical inference layer module, Generative AI module, Recommendation engine module, Feedback loop module.
According to the embodiment of the present invention , as illustrated in FIG. 2, the persistent, multi-project knowledge graph module is designed to unify diverse software engineering artefacts into a single, query able representation. Within this graph, nodes correspond to requirements, code modules, work- item tickets, documentation artefacts, and release entities. Typed edges represent relationships selected from the group consisting of implements, depends‑on, addresses, documents, included‑in, and similar‑to. Each node type captures rich metadata, while edges represent typed relationships such as “implements,” “depends on,” “addresses,” “documents,” “included in,” and “similar to.” This interconnected structure allows traceability, historical analysis, and reuse discovery across multiple projects. This module is implemented on a scalable graph database platform, such as Neo4j, JanusGraph, Amazon Neptune, or an RDF triple store. The underlying storage system supports ACID transactions and horizontal sharding, thereby ensuring high consistency and scalability. The data model is defined in terms of specialized node types and their interconnecting edges. The node schema encompasses requirements, code modules, tickets, documentation, and releases. Each requirement node includes attributes such as identifier, title, description, priority, source, creation time, tags, and traceability links. Each code module node maintains repository URL, file path, language, lines of code, cyclomatic complexity, test coverage, commit hash, and creation time. Ticket nodes include type, status, assignee, timestamps, and links to relevant requirements and code modules. Documentation nodes specify format, URL, version, and their association with code modules or requirements. Release nodes capture version, tag, build identifier, included code modules, and release date.
The edge model enables rich traceability and semantic linking across artifacts. Representative relations include requirement-to-code implementation ([:IMPLEMENTS]), ticket-to-requirement addressing ([:ADDRESSED_BY]), documentation references ([:DOCUMENTS]), code inclusion in releases ([:INCLUDED_IN]), inter-module dependencies ([:DEPENDS_ON]), and similarity relationships across code modules ([:SIMILAR_TO]) weighted by embedding similarity. Each edge carries temporal metadata defining validity intervals, thereby enabling historical and longitudinal queries.
According to the embodiment of the present invention, the knowledge graph is automatically maintained by event-driven ingestion pipelines as illustrated in FIG. 3. These pipelines monitor heterogeneous development tools including version control systems, issue trackers, and documentation repositories. The event-driven ingestion pipeline module ensures that the knowledge graph is kept up to date with evolving software projects. Change detection occurs through webhooks or polling on source control systems, issue trackers, and content management systems. Source code is parsed using code property graph generators to extract abstract syntax trees, control flow graphs, program dependence graphs, and relevant metadata. Natural language text from requirements, tickets, and documentation is processed through transformer-based NLP models, such as BERT, to extract entities and semantic relations. Normalization steps map tool-specific identifiers to canonical universal identifiers, ensuring consistency across heterogeneous platforms. Ingestion operations are implemented as atomic upserts to maintain version history for auditability. Each stage of the pipeline is containerized and orchestrated via an event bus such as Kafka or Pulsar, thereby ensuring resilience, fault tolerance, and at-least-once processing guarantees.
According to the embodiment of the present invention, as illustrated in FIG. 4, the graph-based similarity and embedding module framework computes the relevance of potential reuse candidates. Embedding-based similarity, structural subgraph matching, and attribute-weighted scoring methods determine how closely a requirement or ticket aligns with existing code modules. This graph based similarity and embedding module is applied using graph neural networks such as GraphSAGE or Graph Attention Networks. These models generate embeddings for nodes, which are trained under a contrastive loss objective: nodes that are linked or known to be relevant are pulled closer in the embedding space, whereas unrelated nodes are pushed apart. Similarity scores are computed as cosine similarity between embeddings, further refined by attribute weighting and edge count factors to yield an overall total similarity score.
According to the embodiment of the present invention, to further refine predictions, as illustrated in FIG. 5, the Statistical inference layer module in form of Bayesian inference layer leverages historical data to model the probability of successful reuse under specific contextual conditions such as project domain, programming language, team expertise, or prior defect history. This module is built to estimate contextual probabilities of reuse. Variables such as domain, programming language, component complexity, team experience, historical reuse success rate, and defect likelihood are modelled. Conditional probability tables are learned from historic reuse events stored in the knowledge graph, such as reuse edges tagged with outcome indicators. Posterior probabilities of success under given contexts are computed for candidate components. The model is continuously updated via online learning.
According to the embodiment of the present invention, the system incorporates a generative AI module based on large language models fine-tuned over organizational code and documentation. This module synthesizes adapter code, wrappers, or parameterized modifications to improve compatibility of recommended components with the target project. Generated outputs are accompanied by confidence scores and can include suggested refactoring or integration stubs to improve compatibly. The generative AI module further enhances system intelligence. This module is implemented as a large language model, fine-tuned on organizational source code, commit messages, and documentation. It accepts structured prompts that combine requirements and candidate component signatures, and generates suggested adapter implementations in the target language that satisfies the functional constraints, respects the existing coding standards, and minimizes added dependencies. The generated output includes functional code snippets, unit test stubs, and associated confidence scores, thereby reducing integration effort while adhering to coding standards.
According to the embodiment of the present invention, as illustrated in FIG. 6, the recommendation engine module fuses the similarity metrics, Bayesian probabilities, and generative AI confidence into a composite reuse score. Ranked recommendations are delivered directly to developers through integrated environments such as IDE plug-ins, web dashboards, or CI/CD pipeline hooks. The module integrates signals from the similarity layer, Bayesian inference, and generative model outputs. Given an input requirement or ticket identifier, the system retrieves candidate modules via graph queries. Candidate reuse scores are calculated as weighted combinations of similarity scores, Bayesian probabilities of success, and confidence scores from the language model. Ranked results are presented in a structured payload containing metadata, suggested integration steps, and optional generated adapter code.
ReuseScore = w1·S_total + w2·P(success) + w3·LLM_confidence
where w1 + w2 + w3 =1,
where w1, w2 and w3 are weighting factors selected by a machine‑learning optimizer.
According to the embodiment of the present invention, as illustrated in FIG. 7, the continuous feedback loop module captures developer responses including acceptance, rejection with reasons, or modification of generated code and uses this data to update the statistical and generative models. Over time, this reinforcement learning-like process improves the accuracy, relevance, and trustworthiness of system recommendations. The feedback loop module continuously refines the system. User actions, such as accepting, rejecting, or modifying a recommended component, are captured with associated tags. Bayesian probability tables are updated incrementally, graph embeddings are retrained nightly, and the language model is fine-tuned quarterly with new validated examples. This adaptive loop ensures that recommendations improve over time.
According to the embodiment of the present invention, the method for knowledge graph based representations that enable automated, AI enhanced recommendation of reusable code components and design patterns across multiple projects comprises the steps of:
• receiving, by a processing system, a recommendation request specifying at least a requirement identifier and a target programming language;
• fetching, from a graph database, a requirement node corresponding to the requirement identifier;
• computing, by a graph neural network model, an embedding of the requirement node;
• querying an approximate nearest neighbor index with the embedding to identify a plurality of candidate code modules;
• for each of the candidate code modules:
• applying a Bayesian network to compute a probability of successful reuse of the candidate code module;
• constructing a structured prompt including requirement text, an application programming interface, and the target programming language;
• generating, by a large language model, adapter code for the candidate code module together with a confidence score;
• performing static analysis on the generated adapter code;
• executing unit tests in a sandbox environment;
• assigning a safety score based on whether the unit tests pass or fail;
• computing a language model confidence value as a function of the confidence score and the safety score; and
• storing metadata for the candidate code module including a similarity score, the probability of successful reuse, and the language model confidence value;
2. fusing the similarity score, the probability of successful reuse, and the language model confidence value to compute a composite score for each candidate code module;
3. ranking the plurality of candidate code modules based on the composite scores; and
4. outputting a response including at least an identifier of a candidate code module, its composite score, and the generated adapter code.
Advantages-
• Improved Component Reuse: Achieves high reuse recall exceeding 80% in benchmarked pilot studies, while maintaining precision greater than 70%, thereby ensuring both breadth and accuracy in reuse discovery.
• Reduced Development Effort : Lowers average development time, with approximately 30% fewer person-hours required per feature due to effective identification and adaptation of existing components.
• Accelerated Time-to-Market : Shortens release cycles by enabling faster integration of proven components, reducing duplication of effort across projects.
• Enhanced Software Quality: Minimizes duplicate code and leverages tested components, leading to lower defect density and more reliable software.
• Quantifiable Return on Investment (ROI) : Provides measurable gains through metrics such as reduced redundancy, lower defect rates, improved developer productivity, and shortened delivery timelines.
• Adaptive Recommendations ; Unlike static rule-based systems, the solution continuously evolves through statistical inference and generative AI, ensuring recommendations remain relevant to dynamic code bases and evolving architectures.
• Unified Traceability – Integrates artefacts from multiple tools into a persistent cross-project knowledge graph, eliminating fragmented traceability and enabling holistic search and discovery.
Example:
The system provides multiple exemplary use cases. In one scenario, when a product manager raises a feature request such as “Export data to CSV,” the knowledge graph surfaces an existing exporter module used in a different product line, calculates a high reuse score, and provides a generated wrapper for seamless integration. In another case, when a security vulnerability is discovered in a shared cryptographic library, the knowledge graph identifies all dependent code modules and releases, thereby accelerating patch propagation. In a further scenario of architectural migration, when a team transitions from a monolithic system to microservices, the knowledge graph recommends existing service-oriented components that satisfy legacy requirements, thereby reducing rewrite efforts.
, C , Claims:We claim,
1. A system and method for cross-project knowledge graph based representations for automated reuse recommendation
characterized in that
the system enables enable automated, AI enhanced recommendation of reusable code components and design patterns across multiple projects;
the system comprises of an input unit , a processing unit and output unit , wherein the processing unit comprises of multi project knowledge graph module, Event driven ingestion pipelines module, Graph based similarity metrics module, Statistical inference layer module, Generative AI module, Recommendation engine module, Feedback loop module;
the method for cross-project knowledge graph based representations for automated reuse recommendation comprises the steps of:
• receiving, by a processing system, a recommendation request specifying at least a requirement identifier and a target programming language;
• fetching, from a graph database, a requirement node corresponding to the requirement identifier;
• computing, by a graph neural network model, an embedding of the requirement node;
• querying an approximate nearest neighbor index with the embedding to identify a plurality of candidate code modules;
• for each of the candidate code modules:
(a) applying a Bayesian network to compute a probability of successful reuse of the candidate code module;
(b) constructing a structured prompt including requirement text, an application programming interface, and the target programming language;
(c) generating, by a large language model, adapter code for the candidate code module together with a confidence score;
(d) performing static analysis on the generated adapter code;
(e) executing unit tests in a sandbox environment;
(f) assigning a safety score based on whether the unit tests pass or fail;
(g) computing a language model confidence value as a function of the confidence score and the safety score; and
(h) storing metadata for the candidate code module including a similarity score, the probability of successful reuse, and the language model confidence value;
• fusing the similarity score, the probability of successful reuse, and the language model confidence value to compute a composite score for each candidate code module;
• ranking the plurality of candidate code modules based on the composite scores; and
• outputting a response including at least an identifier of a candidate code module, its composite score, and the generated adapter code.

2. The system and method as claimed in claim 1, wherein processing unit comprises of :
a. the persistent, multi‑project knowledge graph stored in a graph database that is designed to unify diverse software engineering artefacts into a single, query able representation wherein the nodes represent at least one of requirements, code modules, work‑item tickets, documentation artefacts, and software releases; and Typed edges representing relationships selected from the group consisting of implements, depends‑on, addresses, documents, included‑in, and similar‑to; and each requirement node includes attributes such as identifier, title, description, priority, source, creation time, tags, and traceability links and each code module node maintains repository URL, file path, language, lines of code, cyclomatic complexity, test coverage, commit hash, and creation time;
b. one or more event‑driven ingestion pipeline modules that are configured to automatically extract, normalize, and up‑sert into the knowledge graph, artefacts from at least one of source‑control systems, issue‑tracking systems, and documentation repositories;
c. the graph-based similarity and embedding module framework that computes the relevance of potential reuse candidate and embedding-based similarity, structural subgraph matching, and attribute-weighted scoring methods determine how closely a requirement or ticket aligns with existing code modules wherein the module that derives vector representations for at least one node type of the knowledge graph using a graph neural network;
d. the statistical inference layer module that comprises of a Bayesian network that, based on historical reuse outcomes stored in the knowledge graph, computes a probability of successful reuse for a candidate code module given a target requirement;
e. the generative‑AI module that is fine‑tuned on a corpus of the organization’s source code, configured to synthesize adapter or wrapper code that enables integration of a candidate code module with the target requirement;
f. the recommendation engine module that, for a selected target requirement, retrieves candidate code modules from the knowledge graph, calculates a composite reuse score by combining a similarity score derived from the graph‑embedding module, the reuse‑success probability from the Bayesian network, and a confidence metric from the generative‑AI module, and ranks the candidates according to the composite score;
g. the feedback interface through which a developer may accept, reject, or modify a recommended candidate, wherein the developer’s action is recorded and used to update the Bayesian network and to retrain the graph‑embedding and generative‑AI modules.
3. The system and method as claimed in claim 1, wherein wherein the similarity score is a cosine similarity between the target‑requirement embedding and a candidate‑code‑module embedding.

4. The system and method as claimed in claim 1, wherein the ingestion pipelines employ semantic parsing of natural‑language requirement text using a transformer‑based language model.

5. The system and method as claimed in claim 1, wherein the generative‑AI module outputs code in a programming language selected from the group consisting of Java, Python, TypeScript, and Go.

6. The system and method as claimed in claim 1, wherein the feedback interface is implemented as an Integrated Development Environment (IDE) plug‑in that presents ranked recommendations in a side‑panel.

7. The system and method as claimed in claim 1, wherein the Bayesian network includes at least the variables: project domain, programming language, component complexity, historical reuse success rate, and defect likelihood.

8. The system and method as claimed in claim 1, wherein the knowledge graph retains temporal validity intervals for each edge to enable historical queries.

9. The system and method as claimed in claim 1, wherein the system periodically retrains the graph‑embedding generation module using newly added nodes and edges, such that retraining occurs nightly on a compute cluster using stochastic gradient descent and periodically fine‑tunes the generative‑AI module on code snippets that were accepted by developers.

10. The system and method as claimed in claim 1, wherein the event‑driven ingestion pipelines are orchestrated via a distributed streaming platform, the knowledge graph is stored in a horizontally scalable, ACID‑compliant graph database and the recommendation engine can be invoked automatically as a pre‑merge check in a continuous‑integration pipeline.