@eagleoutice/flowr 2.2.13 → 2.2.14

package/queries/catalog/linter-query/linter-query-format.d.ts

@@ -0,0 +1,80 @@
+import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
+import Joi from 'joi';
+import { executeLinterQuery } from './linter-query-executor';
+import type { LintingRuleNames } from '../../../linter/linter-rules';
+import type { ConfiguredLintingRule, LintingResults } from '../../../linter/linter-format';
+export interface LinterQuery extends BaseQueryFormat {
+    readonly type: 'linter';
+    /**
+     * The rules to lint for. If unset, all rules will be included.
+     * Optionally, a {@link ConfiguredLintingRule} can be provided, which additionally includes custom user-supplied values for the linting rules' configurations.
+     */
+    readonly rules?: (LintingRuleNames | ConfiguredLintingRule)[];
+}
+export interface LinterQueryResult extends BaseQueryResult {
+    /**
+     * The results of the linter query, which returns a set of linting results for each rule that was executed.
+     */
+    readonly results: {
+        [L in LintingRuleNames]?: LintingResults<L>;
+    };
+}
+export declare const LinterQueryDefinition: {
+    readonly executor: typeof executeLinterQuery;
+    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, _processed: import("../../../core/steps/pipeline/pipeline").PipelineOutput<import("../../../core/steps/pipeline/pipeline").Pipeline<{
+        readonly name: "parse";
+        readonly humanReadableName: "parse with R shell";
+        readonly description: "Parse the given R code into an AST";
+        readonly processor: (_results: unknown, input: Partial<import("../../../r-bridge/parser").ParseRequiredInput<string>>) => Promise<import("../../../r-bridge/parser").ParseStepOutput<string>>;
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: {
+                (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+                (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+            };
+            readonly 5: ({ parsed }: import("../../../r-bridge/parser").ParseStepOutput<string>, config: import("../../../util/quads").QuadSerializationConfiguration) => string;
+        };
+        readonly dependencies: readonly [];
+        readonly requiredInput: import("../../../r-bridge/parser").ParseRequiredInput<string>;
+    } | {
+        readonly name: "normalize";
+        readonly humanReadableName: "normalize";
+        readonly description: "Normalize the AST to flowR's AST";
+        readonly processor: (results: {
+            parse?: import("../../../r-bridge/parser").ParseStepOutput<string>;
+        }, input: Partial<import("../../../core/steps/all/core/10-normalize").NormalizeRequiredInput>) => import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../../../r-bridge/lang-4.x/ast/model/model").RNode<import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: typeof import("../../../core/print/normalize-printer").normalizedAstToJson;
+            readonly 5: typeof import("../../../core/print/normalize-printer").normalizedAstToQuads;
+            readonly 3: typeof import("../../../core/print/normalize-printer").printNormalizedAstToMermaid;
+            readonly 4: typeof import("../../../core/print/normalize-printer").printNormalizedAstToMermaidUrl;
+        };
+        readonly dependencies: readonly ["parse"];
+        readonly requiredInput: import("../../../core/steps/all/core/10-normalize").NormalizeRequiredInput;
+    } | {
+        readonly humanReadableName: "dataflow";
+        readonly processor: (results: {
+            normalize?: import("../../../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+        }, input: {
+            request?: import("../../../r-bridge/retriever").RParseRequests;
+            parser?: import("../../../r-bridge/parser").Parser<import("../../../r-bridge/parser").KnownParserType>;
+        }) => import("../../../dataflow/info").DataflowInformation;
+        readonly requiredInput: {};
+        readonly name: "dataflow";
+        readonly description: "Construct the dataflow graph";
+        readonly executed: import("../../../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+        readonly printer: {
+            readonly 0: typeof import("../../../core/print/print").internalPrinter;
+            readonly 2: typeof import("../../../core/print/dataflow-printer").dataflowGraphToJson;
+            readonly 5: typeof import("../../../core/print/dataflow-printer").dataflowGraphToQuads;
+            readonly 3: typeof import("../../../core/print/dataflow-printer").dataflowGraphToMermaid;
+            readonly 4: typeof import("../../../core/print/dataflow-printer").dataflowGraphToMermaidUrl;
+        };
+        readonly dependencies: readonly ["normalize"];
+    }>>, queryResults: BaseQueryResult, result: string[]) => true;
+    readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: () => never[];
+};

package/queries/catalog/linter-query/linter-query-format.js

@@ -0,0 +1,43 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LinterQueryDefinition = void 0;
+const joi_1 = __importDefault(require("joi"));
+const linter_query_executor_1 = require("./linter-query-executor");
+const linter_rules_1 = require("../../../linter/linter-rules");
+const linter_format_1 = require("../../../linter/linter-format");
+const ansi_1 = require("../../../util/text/ansi");
+const time_1 = require("../../../util/text/time");
+exports.LinterQueryDefinition = {
+    executor: linter_query_executor_1.executeLinterQuery,
+    asciiSummarizer: (formatter, _processed, queryResults, result) => {
+        const out = queryResults;
+        result.push(`Query: ${(0, ansi_1.bold)('linter', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
+        for (const [ruleName, results] of Object.entries(out.results)) {
+            const rule = linter_rules_1.LintingRules[ruleName];
+            result.push(`   ╰ ${ruleName}:`);
+            for (const certainty of [linter_format_1.LintingCertainty.Definitely, linter_format_1.LintingCertainty.Maybe]) {
+                const certaintyResults = results.results.filter(r => r.certainty === certainty);
+                if (certaintyResults.length) {
+                    result.push(`       ╰ ${certainty}:`);
+                    for (const res of certaintyResults) {
+                        result.push(`           ╰ ${rule.prettyPrint(res)}`);
+                    }
+                }
+            }
+            result.push(`       ╰ Metadata: ${JSON.stringify(results['.meta'])}`);
+        }
+        return true;
+    },
+    schema: joi_1.default.object({
+        type: joi_1.default.string().valid('linter').required().description('The type of the query.'),
+        rules: joi_1.default.array().items(joi_1.default.string().valid(...Object.keys(linter_rules_1.LintingRules)), joi_1.default.object({
+            name: joi_1.default.string().valid(...Object.keys(linter_rules_1.LintingRules)).required(),
+            config: joi_1.default.object()
+        })).description('The rules to lint for. If unset, all rules will be included.')
+    }).description('The linter query lints for the given set of rules and returns the result.'),
+    flattenInvolvedNodes: () => []
+};
+//# sourceMappingURL=linter-query-format.js.map

package/queries/catalog/location-map-query/location-map-query-format.d.ts

@@ -23,4 +23,5 @@ export declare const LocationMapQueryDefinition: {
     readonly executor: typeof executeLocationMapQuery;
     readonly asciiSummarizer: (formatter: OutputFormatter, _processed: unknown, queryResults: BaseQueryResult, result: string[]) => boolean;
     readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: () => never[];
 };

package/queries/catalog/location-map-query/location-map-query-format.js

@@ -23,6 +23,7 @@ exports.LocationMapQueryDefinition = {
     },
     schema: joi_1.default.object({
         type: joi_1.default.string().valid('location-map').required().description('The type of the query.'),
-    }).description('The location map query retrieves the location of every id in the ast.')
+    }).description('The location map query retrieves the location of every id in the ast.'),
+    flattenInvolvedNodes: () => []
 };
 //# sourceMappingURL=location-map-query-format.js.map

package/queries/catalog/normalized-ast-query/normalized-ast-query-format.d.ts

@@ -68,4 +68,5 @@ export declare const NormalizedAstQueryDefinition: {
         readonly dependencies: readonly ["normalize"];
     }>>, queryResults: BaseQueryResult, result: string[]) => true;
     readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: () => never[];
 };

package/queries/catalog/normalized-ast-query/normalized-ast-query-format.js

@@ -19,6 +19,7 @@ exports.NormalizedAstQueryDefinition = {
     },
     schema: joi_1.default.object({
         type: joi_1.default.string().valid('normalized-ast').required().description('The type of the query.'),
-    }).description('The normalized AST query simply returns the normalized AST, there is no need to pass it multiple times!')
+    }).description('The normalized AST query simply returns the normalized AST, there is no need to pass it multiple times!'),
+    flattenInvolvedNodes: () => []
 };
 //# sourceMappingURL=normalized-ast-query-format.js.map

package/queries/catalog/origin-query/origin-query-format.d.ts

@@ -3,6 +3,7 @@ import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
 import Joi from 'joi';
 import { executeResolveValueQuery } from './origin-query-executor';
 import type { Origin } from '../../../dataflow/origin/dfg-get-origin';
+import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 export interface OriginQuery extends BaseQueryFormat {
     readonly type: 'origin';
     /** The slicing criteria to use */
@@ -68,4 +69,5 @@ export declare const OriginQueryDefinition: {
         readonly dependencies: readonly ["normalize"];
     }>>, queryResults: BaseQueryResult, result: string[]) => true;
     readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
 };

package/queries/catalog/origin-query/origin-query-format.js

@@ -22,6 +22,10 @@ exports.OriginQueryDefinition = {
     schema: joi_1.default.object({
         type: joi_1.default.string().valid('origin').required().description('The type of the query.'),
         criterion: joi_1.default.string().required().description('The slicing criteria to use'),
-    }).description('The resolve value query used to get definitions of an identifier')
+    }).description('The resolve value query used to get definitions of an identifier'),
+    flattenInvolvedNodes: (queryResults) => {
+        const out = queryResults;
+        return Object.entries(out.results).flatMap(([_, obj]) => obj?.map(origin => origin.id) ?? []);
+    }
 };
 //# sourceMappingURL=origin-query-format.js.map

package/queries/catalog/project-query/project-query-executor.js

@@ -4,7 +4,7 @@ exports.executeProjectQuery = executeProjectQuery;
 const log_1 = require("../../../util/log");
 function executeProjectQuery({ dataflow }, queries) {
     if (queries.length !== 1) {
-        log_1.log.warn('Id-Map query expects only up to one query, but got', queries.length);
+        log_1.log.warn('Project query expects only up to one query, but got', queries.length);
     }
     return {
         '.meta': {

package/queries/catalog/project-query/project-query-format.d.ts

@@ -64,4 +64,5 @@ export declare const ProjectQueryDefinition: {
         readonly dependencies: readonly ["normalize"];
     }>>, queryResults: BaseQueryResult, result: string[]) => true;
     readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: () => never[];
 };

package/queries/catalog/project-query/project-query-format.js

@@ -21,6 +21,7 @@ exports.ProjectQueryDefinition = {
     },
     schema: joi_1.default.object({
         type: joi_1.default.string().valid('project').required().description('The type of the query.'),
-    }).description('The project query provides information on the analyzed project.')
+    }).description('The project query provides information on the analyzed project.'),
+    flattenInvolvedNodes: () => []
 };
 //# sourceMappingURL=project-query-format.js.map

package/queries/catalog/resolve-value-query/resolve-value-query-format.d.ts

@@ -69,4 +69,5 @@ export declare const ResolveValueQueryDefinition: {
         readonly dependencies: readonly ["normalize"];
     }>>, queryResults: BaseQueryResult, result: string[]) => true;
     readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: () => never[];
 };

package/queries/catalog/resolve-value-query/resolve-value-query-format.js

@@ -44,6 +44,7 @@ exports.ResolveValueQueryDefinition = {
     schema: joi_1.default.object({
         type: joi_1.default.string().valid('resolve-value').required().description('The type of the query.'),
         criteria: joi_1.default.array().items(joi_1.default.string()).min(1).required().description('The slicing criteria to use.'),
-    }).description('The resolve value query used to get definitions of an identifier')
+    }).description('The resolve value query used to get definitions of an identifier'),
+    flattenInvolvedNodes: () => []
 };
 //# sourceMappingURL=resolve-value-query-format.js.map

package/queries/catalog/search-query/search-query-format.d.ts

@@ -70,4 +70,5 @@ export declare const SearchQueryDefinition: {
         readonly dependencies: readonly ["normalize"];
     }>>, queryResults: BaseQueryResult, result: string[]) => true;
     readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
 };

package/queries/catalog/search-query/search-query-format.js

@@ -24,6 +24,10 @@ exports.SearchQueryDefinition = {
     schema: joi_1.default.object({
         type: joi_1.default.string().valid('search').required().description('The type of the query.'),
         search: joi_1.default.object().required().description('The search query to execute.')
-    }).description('The search query searches the normalized AST and dataflow graph for nodes that match the given search query.')
+    }).description('The search query searches the normalized AST and dataflow graph for nodes that match the given search query.'),
+    flattenInvolvedNodes: (queryResults) => {
+        const out = queryResults;
+        return out.results.flatMap(({ ids }) => ids);
+    }
 };
 //# sourceMappingURL=search-query-format.js.map

package/queries/catalog/static-slice-query/static-slice-query-format.d.ts

@@ -4,6 +4,7 @@ import type { DEFAULT_DATAFLOW_PIPELINE, DEFAULT_SLICE_WITHOUT_RECONSTRUCT_PIPEL
 import type { SlicingCriteria } from '../../../slicing/criterion/parse';
 import Joi from 'joi';
 import { executeStaticSliceQuery } from './static-slice-query-executor';
+import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 /** Calculates and returns all clusters encountered in the dataflow graph. */
 export interface StaticSliceQuery extends BaseQueryFormat {
     readonly type: 'static-slice';
@@ -81,4 +82,5 @@ export declare const StaticSliceQueryDefinition: {
         readonly dependencies: readonly ["normalize"];
     }>>, queryResults: BaseQueryResult, result: string[]) => true;
     readonly schema: Joi.ObjectSchema<any>;
+    readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
 };

package/queries/catalog/static-slice-query/static-slice-query-format.js

@@ -38,6 +38,14 @@ exports.StaticSliceQueryDefinition = {
         criteria: joi_1.default.array().items(joi_1.default.string()).min(0).required().description('The slicing criteria to use.'),
         noReconstruction: joi_1.default.boolean().optional().description('Do not reconstruct the slice into readable code.'),
         noMagicComments: joi_1.default.boolean().optional().description('Should the magic comments (force-including lines within the slice) be ignored?')
-    }).description('Slice query used to slice the dataflow graph')
+    }).description('Slice query used to slice the dataflow graph'),
+    flattenInvolvedNodes: (queryResults) => {
+        const flattened = [];
+        const out = queryResults;
+        for (const [_, obj] of Object.entries(out.results)) {
+            flattened.push(...obj.slice.result);
+        }
+        return flattened;
+    }
 };
 //# sourceMappingURL=static-slice-query-format.js.map

package/queries/query.d.ts

@@ -21,7 +21,9 @@ import type { ResolveValueQuery } from './catalog/resolve-value-query/resolve-va
 import type { DataflowLensQuery } from './catalog/dataflow-lens-query/dataflow-lens-query-format';
 import type { ProjectQuery } from './catalog/project-query/project-query-format';
 import type { OriginQuery } from './catalog/origin-query/origin-query-format';
-export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | DataflowLensQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | LineageQuery | DependenciesQuery | LocationMapQuery | HappensBeforeQuery | ResolveValueQuery | ProjectQuery | OriginQuery;
+import type { LinterQuery } from './catalog/linter-query/linter-query-format';
+import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
+export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | DataflowLensQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | LineageQuery | DependenciesQuery | LocationMapQuery | HappensBeforeQuery | ResolveValueQuery | ProjectQuery | OriginQuery | LinterQuery;
 export type QueryArgumentsWithType<QueryType extends BaseQueryFormat['type']> = Query & {
     type: QueryType;
 };
@@ -33,17 +35,24 @@ export interface SupportedQuery<QueryType extends BaseQueryFormat['type']> {
     executor: QueryExecutor<QueryArgumentsWithType<QueryType>, BaseQueryResult>;
     asciiSummarizer: (formatter: OutputFormatter, processed: PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>, queryResults: BaseQueryResult, resultStrings: string[]) => boolean;
     schema: Joi.ObjectSchema;
+    /**
+     * Flattens the involved query nodes to be added to a flowR search when the {@link fromQuery} function is used based on the given result after this query is executed.
+     * If this query does not involve any nodes, an empty array can be returned.
+     */
+    flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
 }
 export declare const SupportedQueries: {
     readonly 'call-context': {
         readonly executor: typeof import("./catalog/call-context-query/call-context-query-executor").executeCallContextQueries;
         readonly asciiSummarizer: (formatter: OutputFormatter, processed: PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>, queryResults: BaseQueryResult, result: string[]) => boolean;
         readonly schema: Joi.ObjectSchema<any>;
+        readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
     };
     readonly config: {
         readonly executor: typeof import("./catalog/config-query/config-query-executor").executeConfigQuery;
         readonly asciiSummarizer: (formatter: OutputFormatter, _processed: unknown, queryResults: BaseQueryResult, result: string[]) => boolean;
         readonly schema: Joi.ObjectSchema<any>;
+        readonly flattenInvolvedNodes: () => never[];
     };
     readonly dataflow: {
         readonly executor: typeof import("./catalog/dataflow-query/dataflow-query-executor").executeDataflowQuery;
@@ -102,6 +111,7 @@ export declare const SupportedQueries: {
             readonly dependencies: readonly ["normalize"];
         }>>, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
+        readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
     };
     readonly 'dataflow-lens': {
         readonly executor: typeof import("./catalog/dataflow-lens-query/dataflow-lens-query-executor").executeDataflowLensQuery;
@@ -160,6 +170,7 @@ export declare const SupportedQueries: {
             readonly dependencies: readonly ["normalize"];
         }>>, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
+        readonly flattenInvolvedNodes: () => never[];
     };
     readonly 'id-map': {
         readonly executor: typeof import("./catalog/id-map-query/id-map-query-executor").executeIdMapQuery;
@@ -218,6 +229,7 @@ export declare const SupportedQueries: {
             readonly dependencies: readonly ["normalize"];
         }>>, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
+        readonly flattenInvolvedNodes: () => never[];
     };
     readonly 'normalized-ast': {
         readonly executor: typeof import("./catalog/normalized-ast-query/normalized-ast-query-executor").executeNormalizedAstQuery;
@@ -276,6 +288,7 @@ export declare const SupportedQueries: {
             readonly dependencies: readonly ["normalize"];
         }>>, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
+        readonly flattenInvolvedNodes: () => never[];
     };
     readonly 'dataflow-cluster': {
         readonly executor: typeof import("./catalog/cluster-query/cluster-query-executor").executeDataflowClusterQuery;
@@ -334,6 +347,7 @@ export declare const SupportedQueries: {
             readonly dependencies: readonly ["normalize"];
         }>>, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
+        readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
     };
     readonly 'static-slice': {
         readonly executor: typeof import("./catalog/static-slice-query/static-slice-query-executor").executeStaticSliceQuery;
@@ -392,6 +406,7 @@ export declare const SupportedQueries: {
             readonly dependencies: readonly ["normalize"];
         }>>, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
+        readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
     };
     readonly lineage: {
         readonly executor: typeof import("./catalog/lineage-query/lineage-query-executor").executeLineageQuery;
@@ -450,6 +465,7 @@ export declare const SupportedQueries: {
             readonly dependencies: readonly ["normalize"];
         }>>, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
+        readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
     };
     readonly dependencies: {
         readonly executor: typeof import("./catalog/dependencies-query/dependencies-query-executor").executeDependenciesQuery;
@@ -508,11 +524,13 @@ export declare const SupportedQueries: {
             readonly dependencies: readonly ["normalize"];
         }>>, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
+        readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
     };
     readonly 'location-map': {
         readonly executor: typeof import("./catalog/location-map-query/location-map-query-executor").executeLocationMapQuery;
         readonly asciiSummarizer: (formatter: OutputFormatter, _processed: unknown, queryResults: BaseQueryResult, result: string[]) => boolean;
         readonly schema: Joi.ObjectSchema<any>;
+        readonly flattenInvolvedNodes: () => never[];
     };
     readonly search: {
         readonly executor: typeof import("./catalog/search-query/search-query-executor").executeSearch;
@@ -571,6 +589,7 @@ export declare const SupportedQueries: {
             readonly dependencies: readonly ["normalize"];
         }>>, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
+        readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
     };
     readonly 'happens-before': {
         readonly executor: typeof import("./catalog/happens-before-query/happens-before-query-executor").executeHappensBefore;
@@ -629,6 +648,7 @@ export declare const SupportedQueries: {
             readonly dependencies: readonly ["normalize"];
         }>>, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
+        readonly flattenInvolvedNodes: () => never[];
     };
     readonly 'resolve-value': {
         readonly executor: typeof import("./catalog/resolve-value-query/resolve-value-query-executor").executeResolveValueQuery;
@@ -687,6 +707,7 @@ export declare const SupportedQueries: {
             readonly dependencies: readonly ["normalize"];
         }>>, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
+        readonly flattenInvolvedNodes: () => never[];
     };
     readonly project: {
         readonly executor: typeof import("./catalog/project-query/project-query-executor").executeProjectQuery;
@@ -745,6 +766,7 @@ export declare const SupportedQueries: {
             readonly dependencies: readonly ["normalize"];
         }>>, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
+        readonly flattenInvolvedNodes: () => never[];
     };
     readonly origin: {
         readonly executor: typeof import("./catalog/origin-query/origin-query-executor").executeResolveValueQuery;
@@ -803,6 +825,66 @@ export declare const SupportedQueries: {
             readonly dependencies: readonly ["normalize"];
         }>>, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
+        readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
+    };
+    readonly linter: {
+        readonly executor: typeof import("./catalog/linter-query/linter-query-executor").executeLinterQuery;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _processed: PipelineOutput<import("../core/steps/pipeline/pipeline").Pipeline<{
+            readonly name: "parse";
+            readonly humanReadableName: "parse with R shell";
+            readonly description: "Parse the given R code into an AST";
+            readonly processor: (_results: unknown, input: Partial<import("../r-bridge/parser").ParseRequiredInput<string>>) => Promise<import("../r-bridge/parser").ParseStepOutput<string>>;
+            readonly executed: import("../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+            readonly printer: {
+                readonly 0: typeof import("../core/print/print").internalPrinter;
+                readonly 2: {
+                    (value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
+                    (value: any, replacer?: (number | string)[] | null, space?: string | number): string;
+                };
+                readonly 5: ({ parsed }: import("../r-bridge/parser").ParseStepOutput<string>, config: import("../util/quads").QuadSerializationConfiguration) => string;
+            };
+            readonly dependencies: readonly [];
+            readonly requiredInput: import("../r-bridge/parser").ParseRequiredInput<string>;
+        } | {
+            readonly name: "normalize";
+            readonly humanReadableName: "normalize";
+            readonly description: "Normalize the AST to flowR's AST";
+            readonly processor: (results: {
+                parse?: import("../r-bridge/parser").ParseStepOutput<string>;
+            }, input: Partial<import("../core/steps/all/core/10-normalize").NormalizeRequiredInput>) => import("../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation, import("../r-bridge/lang-4.x/ast/model/model").RNode<import("../r-bridge/lang-4.x/ast/model/processing/decorate").ParentInformation>>;
+            readonly executed: import("../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+            readonly printer: {
+                readonly 0: typeof import("../core/print/print").internalPrinter;
+                readonly 2: typeof import("../core/print/normalize-printer").normalizedAstToJson;
+                readonly 5: typeof import("../core/print/normalize-printer").normalizedAstToQuads;
+                readonly 3: typeof import("../core/print/normalize-printer").printNormalizedAstToMermaid;
+                readonly 4: typeof import("../core/print/normalize-printer").printNormalizedAstToMermaidUrl;
+            };
+            readonly dependencies: readonly ["parse"];
+            readonly requiredInput: import("../core/steps/all/core/10-normalize").NormalizeRequiredInput;
+        } | {
+            readonly humanReadableName: "dataflow";
+            readonly processor: (results: {
+                normalize?: import("../r-bridge/lang-4.x/ast/model/processing/decorate").NormalizedAst;
+            }, input: {
+                request?: import("../r-bridge/retriever").RParseRequests;
+                parser?: import("../r-bridge/parser").Parser<import("../r-bridge/parser").KnownParserType>;
+            }) => import("../dataflow/info").DataflowInformation;
+            readonly requiredInput: {};
+            readonly name: "dataflow";
+            readonly description: "Construct the dataflow graph";
+            readonly executed: import("../core/steps/pipeline-step").PipelineStepStage.OncePerFile;
+            readonly printer: {
+                readonly 0: typeof import("../core/print/print").internalPrinter;
+                readonly 2: typeof import("../core/print/dataflow-printer").dataflowGraphToJson;
+                readonly 5: typeof import("../core/print/dataflow-printer").dataflowGraphToQuads;
+                readonly 3: typeof import("../core/print/dataflow-printer").dataflowGraphToMermaid;
+                readonly 4: typeof import("../core/print/dataflow-printer").dataflowGraphToMermaidUrl;
+            };
+            readonly dependencies: readonly ["normalize"];
+        }>>, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly schema: Joi.ObjectSchema<any>;
+        readonly flattenInvolvedNodes: () => never[];
     };
 };
 export type SupportedQueryTypes = keyof typeof SupportedQueries;

package/queries/query.js

@@ -29,6 +29,7 @@ const resolve_value_query_format_1 = require("./catalog/resolve-value-query/reso
 const dataflow_lens_query_format_1 = require("./catalog/dataflow-lens-query/dataflow-lens-query-format");
 const project_query_format_1 = require("./catalog/project-query/project-query-format");
 const origin_query_format_1 = require("./catalog/origin-query/origin-query-format");
+const linter_query_format_1 = require("./catalog/linter-query/linter-query-format");
 exports.SupportedQueries = {
     'call-context': call_context_query_format_1.CallContextQueryDefinition,
     'config': config_query_format_1.ConfigQueryDefinition,
@@ -46,6 +47,7 @@ exports.SupportedQueries = {
     'resolve-value': resolve_value_query_format_1.ResolveValueQueryDefinition,
     'project': project_query_format_1.ProjectQueryDefinition,
     'origin': origin_query_format_1.OriginQueryDefinition,
+    'linter': linter_query_format_1.LinterQueryDefinition
 };
 function executeQueriesOfSameType(data, ...queries) {
     (0, assert_1.guard)(queries.length > 0, 'At least one query must be provided');

package/r-bridge/retriever.js

@@ -72,7 +72,7 @@ function requestProviderFromText(text) {
             if (ignoreCase) {
                 return Object.keys(text).find(p => p.toLowerCase() === path.toLowerCase());
             }
-            return text[path] ? path : undefined;
+            return text[path] !== undefined ? path : undefined;
         },
         createRequest(path) {
             return {

package/search/flowr-search-builder.d.ts

@@ -1,10 +1,14 @@
 import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { FlowrSearchElement, FlowrSearchElements, FlowrSearchGetFilter } from './flowr-search';
+import type { FlowrSearchElement, FlowrSearchElementFromQuery, FlowrSearchElements, FlowrSearchGetFilter } from './flowr-search';
 import type { FlowrFilterExpression } from './flowr-search-filters';
 import type { FlowrSearchGeneratorNode, GeneratorNames } from './search-executor/search-generators';
 import type { FlowrSearchTransformerNode, GetOutputOfTransformer, TransformerNames } from './search-executor/search-transformer';
 import type { SlicingCriteria } from '../slicing/criterion/parse';
 import type { ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { Enrichment, EnrichmentArguments } from './search-executor/search-enrichers';
+import type { MapperArguments } from './search-executor/search-mappers';
+import { Mapper } from './search-executor/search-mappers';
+import type { Query } from '../queries/query';
 type FlowrCriteriaReturn<C extends SlicingCriteria> = FlowrSearchElements<ParentInformation, C extends [] ? never : C extends [infer _] ? [
     FlowrSearchElement<ParentInformation>
 ] : FlowrSearchElement<ParentInformation>[]>;
@@ -19,6 +23,12 @@ export declare const FlowrSearchGenerator: {
      * see {@link FlowrSearchGenerator.criterion} for a serializable alternative (passing the ids with `$id`).
      */
     readonly from: (from: FlowrSearchElement<ParentInformation> | FlowrSearchElement<ParentInformation>[]) => FlowrSearchBuilder<"from">;
+    /**
+     * Initializes a new search query based on the results of the given JSON query or queries.
+     * Internally, the {@link SupportedQuery#flattenInvolvedNodes} function is used to flatten the resulting nodes of the query.
+     * Please note that, due to the fact that not every query involves dataflow nodes, the search may not contain any elements at all for certain queries.
+     */
+    readonly fromQuery: (...from: readonly Query[]) => FlowrSearchBuilder<"from-query", [], ParentInformation, FlowrSearchElements<ParentInformation, FlowrSearchElementFromQuery<ParentInformation>[]>>;
     /**
      * Returns all elements (nodes/dataflow vertices) from the given data.
      */
@@ -71,6 +81,12 @@ export declare const Q: {
      * see {@link FlowrSearchGenerator.criterion} for a serializable alternative (passing the ids with `$id`).
      */
     readonly from: (from: FlowrSearchElement<ParentInformation> | FlowrSearchElement<ParentInformation>[]) => FlowrSearchBuilder<"from">;
+    /**
+     * Initializes a new search query based on the results of the given JSON query or queries.
+     * Internally, the {@link SupportedQuery#flattenInvolvedNodes} function is used to flatten the resulting nodes of the query.
+     * Please note that, due to the fact that not every query involves dataflow nodes, the search may not contain any elements at all for certain queries.
+     */
+    readonly fromQuery: (...from: readonly Query[]) => FlowrSearchBuilder<"from-query", [], ParentInformation, FlowrSearchElements<ParentInformation, FlowrSearchElementFromQuery<ParentInformation>[]>>;
     /**
      * Returns all elements (nodes/dataflow vertices) from the given data.
      */
@@ -168,6 +184,19 @@ export declare class FlowrSearchBuilder<Generator extends GeneratorNames, Transf
      * select returns only the elements at the given indices.
      */
     select<Select extends number[]>(...select: Select): FlowrSearchBuilderOut<Generator, Transformers, Info, 'select'>;
+    /**
+     * Adds the given enrichment to each element of the search.
+     * Added enrichments can later be retrieved using the {@link enrichmentContent} function.
+     */
+    with<ConcreteEnrichment extends Enrichment>(enrichment: ConcreteEnrichment, args?: EnrichmentArguments<ConcreteEnrichment>): FlowrSearchBuilderOut<Generator, Transformers, Info, 'with'>;
+    /**
+     * Maps the elements of the search to new values using the given mapper function.
+     */
+    map<MapperType extends Mapper>(mapper: MapperType, args: MapperArguments<MapperType>): FlowrSearchBuilderOut<Generator, Transformers, Info, 'map'>;
+    /**
+     * A convenience function that combines {@link with} and the {@link Mapper.Enrichment} mapper to immediately add an enrichment and then map to its value(s).
+     */
+    get<ConcreteEnrichment extends Enrichment>(enrichment: ConcreteEnrichment, args?: EnrichmentArguments<ConcreteEnrichment>): FlowrSearchBuilderOut<Generator, Transformers, Info, 'with' | 'map'>;
     /**
      * merge combines the search results with those of another search.
      */
@@ -183,7 +212,7 @@ export declare class FlowrSearchBuilder<Generator extends GeneratorNames, Transf
  * This type summarizes all types that can be used in places in which the API expects you to provide a search query.
  * @see {@link FlowrSearch}
  */
-export type FlowrSearchLike = FlowrSearch | FlowrSearchBuilderType;
+export type FlowrSearchLike<Info = ParentInformation, Generator extends GeneratorNames = GeneratorNames, Transformers extends TransformerNames[] = TransformerNames[], ElementType = FlowrSearchElements<Info, FlowrSearchElement<Info>[]>> = FlowrSearch<Info, Generator, Transformers, ElementType> | FlowrSearchBuilderType<Generator, Transformers, Info, ElementType>;
 export type SearchOutput<Search> = Search extends FlowrSearch ? Search : Search extends FlowrSearchBuilderType<infer Generator, infer Transformers, infer Info, infer Elements> ? FlowrSearch<Info, Generator, Transformers, Elements> : never;
 /**
  * Freezes any accepted {@link FlowrSearchLike} into a {@link FlowrSearch}.