@eagleoutice/flowr 2.6.1 → 2.6.3

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

@@ -9,6 +9,23 @@ const time_1 = require("../../../util/text/time");
 const joi_1 = __importDefault(require("joi"));
 const resolve_value_query_executor_1 = require("./resolve-value-query-executor");
 const r_value_1 = require("../../../dataflow/eval/values/r-value");
+const slice_query_parser_1 = require("../../../cli/repl/parser/slice-query-parser");
+function resolveValueLineParser(output, line, _config) {
+    const criteria = (0, slice_query_parser_1.sliceCriteriaParser)(line[0]);
+    if (!criteria || criteria.length == 0) {
+        output.stderr(output.formatter.format('Invalid resolve-value query format, slicing criteria must be given in the form "(criterion1;criterion2;...)"', { color: 1 /* Colors.Red */, effect: ansi_1.ColorEffect.Foreground, style: 1 /* FontStyles.Bold */ }));
+        return { query: [] };
+    }
+    return {
+        query: [
+            {
+                type: 'resolve-value',
+                criteria: criteria,
+            }
+        ],
+        rCode: line[1]
+    };
+}
 exports.ResolveValueQueryDefinition = {
     executor: resolve_value_query_executor_1.executeResolveValueQuery,
     asciiSummarizer: (formatter, _analyzer, queryResults, result) => {
@@ -17,10 +34,11 @@ exports.ResolveValueQueryDefinition = {
         for (const [fingerprint, obj] of Object.entries(out.results)) {
             const { criteria } = JSON.parse(fingerprint);
             result.push(`   ╰ Values for {${criteria.join(', ')}}`);
-            result.push(`   	╰ ${obj.values.map(v => (0, r_value_1.stringifyValue)(v)).join(', ')}`);
+            result.push(`     ╰ ${obj.values.map(v => (0, r_value_1.stringifyValue)(v)).join(', ')}`);
         }
         return true;
     },
+    fromLine: resolveValueLineParser,
     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.'),

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

@@ -1,3 +1,6 @@
 import type { BasicQueryData } from '../../base-query-format';
 import type { SearchQuery, SearchQueryResult } from './search-query-format';
+/**
+ * Executes the given search queries using the provided analyzer.
+ */
 export declare function executeSearch({ analyzer }: BasicQueryData, queries: readonly SearchQuery[]): Promise<SearchQueryResult>;

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

@@ -2,6 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.executeSearch = executeSearch;
 const flowr_search_executor_1 = require("../../../search/flowr-search-executor");
+/**
+ * Executes the given search queries using the provided analyzer.
+ */
 async function executeSearch({ analyzer }, queries) {
     const start = Date.now();
     const results = [];

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

@@ -15,7 +15,7 @@ export interface SearchQueryResult extends BaseQueryResult {
 }
 export declare const SearchQueryDefinition: {
     readonly executor: typeof executeSearch;
-    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, _analyzer: import("../../../project/flowr-analyzer").FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, _analyzer: import("../../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../../../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => true;
     readonly schema: Joi.ObjectSchema<any>;
     readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
 };

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

@@ -1,4 +1,13 @@
 import type { StaticSliceQuery, StaticSliceQueryResult } from './static-slice-query-format';
 import type { BasicQueryData } from '../../base-query-format';
+/**
+ * Produce a fingerprint string for a static slice query
+ */
 export declare function fingerPrintOfQuery(query: StaticSliceQuery): string;
+/**
+ * Execute static slice queries, catching duplicates with the same fingerprint
+ * @param analyzer - The basic query data containing the analyzer
+ * @param queries - The static slice queries to execute
+ * @returns The results of the static slice queries
+ */
 export declare function executeStaticSliceQuery({ analyzer }: BasicQueryData, queries: readonly StaticSliceQuery[]): Promise<StaticSliceQueryResult>;

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

@@ -8,9 +8,18 @@ const auto_select_defaults_1 = require("../../../reconstruct/auto-select/auto-se
 const magic_comments_1 = require("../../../reconstruct/auto-select/magic-comments");
 const log_1 = require("../../../util/log");
 const _00_slice_1 = require("../../../core/steps/all/static-slicing/00-slice");
+/**
+ * Produce a fingerprint string for a static slice query
+ */
 function fingerPrintOfQuery(query) {
     return JSON.stringify(query);
 }
+/**
+ * Execute static slice queries, catching duplicates with the same fingerprint
+ * @param analyzer - The basic query data containing the analyzer
+ * @param queries - The static slice queries to execute
+ * @returns The results of the static slice queries
+ */
 async function executeStaticSliceQuery({ analyzer }, queries) {
     const start = Date.now();
     const results = {};
@@ -28,7 +37,7 @@ async function executeStaticSliceQuery({ analyzer }, queries) {
         }
         else {
             const reconstructStart = Date.now();
-            const reconstruct = (0, reconstruct_1.reconstructToCode)(await analyzer.normalize(), slice.result, noMagicComments ? auto_select_defaults_1.doNotAutoSelect : (0, magic_comments_1.makeMagicCommentHandler)(auto_select_defaults_1.doNotAutoSelect));
+            const reconstruct = (0, reconstruct_1.reconstructToCode)(await analyzer.normalize(), { nodes: slice.result }, noMagicComments ? auto_select_defaults_1.doNotAutoSelect : (0, magic_comments_1.makeMagicCommentHandler)(auto_select_defaults_1.doNotAutoSelect));
             const reconstructEnd = Date.now();
             results[key] = {
                 slice: { ...slice, '.meta': { timing: sliceEnd - sliceStart } },

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

@@ -2,10 +2,13 @@ import type { BaseQueryFormat, BaseQueryResult } from '../../base-query-format';
 import type { PipelineOutput } from '../../../core/steps/pipeline/pipeline';
 import type { DEFAULT_DATAFLOW_PIPELINE, DEFAULT_SLICE_WITHOUT_RECONSTRUCT_PIPELINE, DEFAULT_SLICING_PIPELINE } from '../../../core/steps/pipeline/default-pipelines';
 import type { SlicingCriteria } from '../../../slicing/criterion/parse';
+import type { ParsedQueryLine } from '../../query';
 import Joi from 'joi';
 import { executeStaticSliceQuery } from './static-slice-query-executor';
 import { SliceDirection } from '../../../core/steps/all/static-slicing/00-slice';
 import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
+import type { ReplOutput } from '../../../cli/repl/commands/repl-main';
+import type { FlowrConfigOptions } from '../../../config';
 /** Calculates and returns all clusters encountered in the dataflow graph. */
 export interface StaticSliceQuery extends BaseQueryFormat {
     readonly type: 'static-slice';
@@ -28,9 +31,12 @@ export interface StaticSliceQueryResult extends BaseQueryResult {
      */
     results: Record<string, Omit<PipelineOutput<typeof DEFAULT_SLICING_PIPELINE>, keyof PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>> | Omit<PipelineOutput<typeof DEFAULT_SLICE_WITHOUT_RECONSTRUCT_PIPELINE>, keyof PipelineOutput<typeof DEFAULT_DATAFLOW_PIPELINE>>>;
 }
+declare function sliceQueryLineParser(output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions): ParsedQueryLine<'static-slice'>;
 export declare const StaticSliceQueryDefinition: {
     readonly executor: typeof executeStaticSliceQuery;
-    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, _analyzer: import("../../../project/flowr-analyzer").FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+    readonly asciiSummarizer: (formatter: import("../../../util/text/ansi").OutputFormatter, _analyzer: import("../../../project/flowr-analyzer").ReadonlyFlowrAnalysisProvider<import("../../../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => true;
+    readonly fromLine: typeof sliceQueryLineParser;
     readonly schema: Joi.ObjectSchema<any>;
     readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
 };
+export {};

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

@@ -10,10 +10,37 @@ const joi_1 = __importDefault(require("joi"));
 const static_slice_query_executor_1 = require("./static-slice-query-executor");
 const query_print_1 = require("../../query-print");
 const _00_slice_1 = require("../../../core/steps/all/static-slicing/00-slice");
+const slice_query_parser_1 = require("../../../cli/repl/parser/slice-query-parser");
+function sliceQueryLineParser(output, line, _config) {
+    const criteria = (0, slice_query_parser_1.sliceCriteriaParser)(line[0]);
+    const direction = (0, slice_query_parser_1.sliceDirectionParser)(line[0]);
+    if (!criteria || criteria.length == 0) {
+        output.stderr(output.formatter.format('Invalid static-slice query format, slicing criteria must be given in the form "(criterion1;criterion2;...)"', { color: 1 /* Colors.Red */, effect: ansi_1.ColorEffect.Foreground, style: 1 /* FontStyles.Bold */ }));
+        return { query: [] };
+    }
+    return { query: [
+            {
+                type: 'static-slice',
+                criteria: criteria,
+                direction: direction,
+            }
+        ], rCode: line[1] };
+}
 exports.StaticSliceQueryDefinition = {
     executor: static_slice_query_executor_1.executeStaticSliceQuery,
     asciiSummarizer: (formatter, _analyzer, queryResults, result) => {
         const out = queryResults;
+        if (Object.keys(out.results).length === 1) {
+            // just print the single result without fingerprint
+            const [, obj] = Object.entries(out.results)[0];
+            if ('reconstruct' in obj) {
+                const code = Array.isArray(obj.reconstruct.code) ? obj.reconstruct.code : [obj.reconstruct.code];
+                if (code.length === 1) {
+                    result.push(code[0]);
+                    return true;
+                }
+            }
+        }
         result.push(`Query: ${(0, ansi_1.bold)('static-slice', formatter)} (${(0, time_1.printAsMs)(out['.meta'].timing, 0)})`);
         for (const [fingerprint, obj] of Object.entries(out.results)) {
             const { criteria, noMagicComments, noReconstruction } = JSON.parse(fingerprint);
@@ -26,7 +53,8 @@ exports.StaticSliceQueryDefinition = {
             }
             result.push(`   ╰ Slice for {${criteria.join(', ')}} ${addons.join(', ')}`);
             if ('reconstruct' in obj) {
-                result.push('     ╰ Code (newline as <code>&#92;n</code>): <code>' + obj.reconstruct.code.split('\n').join('\\n') + '</code>');
+                const code = Array.isArray(obj.reconstruct.code) ? obj.reconstruct.code : [obj.reconstruct.code];
+                result.push('     ╰ Code (newline as <code>&#92;n</code>): <code>' + code.flatMap(c => c.split('\n')).join('\\n') + '</code>');
             }
             else {
                 result.push(`     ╰ Id List: {${(0, query_print_1.summarizeIdsIfTooLong)(formatter, [...obj.slice.result])}}`);
@@ -34,6 +62,7 @@ exports.StaticSliceQueryDefinition = {
         }
         return true;
     },
+    fromLine: sliceQueryLineParser,
     schema: joi_1.default.object({
         type: joi_1.default.string().valid('static-slice').required().description('The type of the query.'),
         criteria: joi_1.default.array().items(joi_1.default.string()).min(0).required().description('The slicing criteria to use.'),

package/queries/query-print.d.ts

@@ -1,8 +1,24 @@
-import type { OutputFormatter } from '../util/text/ansi';
-import type { Queries, QueryResults, SupportedQueryTypes } from './query';
+import { type OutputFormatter } from '../util/text/ansi';
+import { type Queries, type QueryResults, type SupportedQueryTypes } from './query';
 import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { AstIdMap, ParentInformation } from '../r-bridge/lang-4.x/ast/model/processing/decorate';
-import type { FlowrAnalysisProvider } from '../project/flowr-analyzer';
+import type { ReadonlyFlowrAnalysisProvider } from '../project/flowr-analyzer';
+/**
+ * Converts call context query results to an ASCII representation
+ */
 export declare function asciiCallContext(formatter: OutputFormatter, results: QueryResults<'call-context'>['call-context'], idMap: AstIdMap<ParentInformation>): string;
+/**
+ * Summarizes a list of node IDs, shortening the output if it is too long
+ * @example
+ * ```ts
+ * summarizeIdsIfTooLong(markdownFormatter, ['id1', 'id2', 'id3']);
+ * // returns 'id1, id2, id3'
+ * summarizeIdsIfTooLong(markdownFormatter, [<array of many ids>]);
+ * // returns 'id1, id2, id3, ... (see JSON)' with a tooltip containing the full JSON array
+ * ```
+ */
 export declare function summarizeIdsIfTooLong(formatter: OutputFormatter, ids: readonly NodeId[]): string;
-export declare function asciiSummaryOfQueryResult<S extends SupportedQueryTypes>(formatter: OutputFormatter, totalInMs: number, results: QueryResults<S>, analyzer: FlowrAnalysisProvider, queries: Queries<S>): Promise<string>;
+/**
+ * Generates an ASCII summary of the given query results
+ */
+export declare function asciiSummaryOfQueryResult<S extends SupportedQueryTypes>(formatter: OutputFormatter, totalInMs: number, results: QueryResults<S>, analyzer: ReadonlyFlowrAnalysisProvider, queries: Queries<S>): Promise<string>;

package/queries/query-print.js

@@ -10,8 +10,8 @@ const time_1 = require("../util/text/time");
 const built_in_1 = require("../dataflow/environments/built-in");
 function nodeString(nodeId, formatter, idMap) {
     const isObj = typeof nodeId === 'object' && nodeId !== null && 'id' in nodeId;
-    const id = isObj ? nodeId.id : nodeId;
-    const info = isObj ? nodeId.info : undefined;
+    const id = isObj ? nodeId?.id : nodeId;
+    const info = isObj ? nodeId?.info : undefined;
     if ((0, built_in_1.isBuiltIn)(id)) {
         return (0, ansi_1.italic)(id, formatter) + (info ? ` (${JSON.stringify(info)})` : '');
     }
@@ -43,6 +43,9 @@ function asciiCallContextSubHit(formatter, results, idMap) {
     }
     return result.join(', ');
 }
+/**
+ * Converts call context query results to an ASCII representation
+ */
 function asciiCallContext(formatter, results, idMap) {
     /* traverse over 'kinds' and within them 'subkinds' */
     const result = [];
@@ -54,6 +57,16 @@ function asciiCallContext(formatter, results, idMap) {
     }
     return result.join('\n');
 }
+/**
+ * Summarizes a list of node IDs, shortening the output if it is too long
+ * @example
+ * ```ts
+ * summarizeIdsIfTooLong(markdownFormatter, ['id1', 'id2', 'id3']);
+ * // returns 'id1, id2, id3'
+ * summarizeIdsIfTooLong(markdownFormatter, [<array of many ids>]);
+ * // returns 'id1, id2, id3, ... (see JSON)' with a tooltip containing the full JSON array
+ * ```
+ */
 function summarizeIdsIfTooLong(formatter, ids) {
     const naive = ids.join(', ');
     if (naive.length <= 20) {
@@ -69,6 +82,9 @@ function summarizeIdsIfTooLong(formatter, ids) {
     }
     return formatter === ansi_1.markdownFormatter ? (0, html_hover_over_1.textWithTooltip)(acc, JSON.stringify(ids)) : acc;
 }
+/**
+ * Generates an ASCII summary of the given query results
+ */
 async function asciiSummaryOfQueryResult(formatter, totalInMs, results, analyzer, queries) {
     const result = [];
     for (const [query, queryResults] of Object.entries(results)) {

package/queries/query.d.ts

@@ -1,48 +1,62 @@
-import type { CallContextQuery } from './catalog/call-context-query/call-context-query-format';
+import { type CallContextQuery } from './catalog/call-context-query/call-context-query-format';
 import type { BaseQueryFormat, BaseQueryResult, BasicQueryData } from './base-query-format';
-import type { VirtualQueryArgumentsWithType } from './virtual-query/virtual-queries';
+import { type VirtualQueryArgumentsWithType } from './virtual-query/virtual-queries';
 import type { VirtualCompoundConstraint } from './virtual-query/compound-query';
-import type { DataflowQuery } from './catalog/dataflow-query/dataflow-query-format';
-import type { IdMapQuery } from './catalog/id-map-query/id-map-query-format';
-import type { NormalizedAstQuery } from './catalog/normalized-ast-query/normalized-ast-query-format';
-import type { LineageQuery } from './catalog/lineage-query/lineage-query-format';
-import type { StaticSliceQuery } from './catalog/static-slice-query/static-slice-query-format';
-import type { DataflowClusterQuery } from './catalog/cluster-query/cluster-query-format';
-import type { DependenciesQuery } from './catalog/dependencies-query/dependencies-query-format';
+import { type DataflowQuery } from './catalog/dataflow-query/dataflow-query-format';
+import { type IdMapQuery } from './catalog/id-map-query/id-map-query-format';
+import { type NormalizedAstQuery } from './catalog/normalized-ast-query/normalized-ast-query-format';
+import { type StaticSliceQuery } from './catalog/static-slice-query/static-slice-query-format';
+import { type DataflowClusterQuery } from './catalog/cluster-query/cluster-query-format';
+import { type DependenciesQuery } from './catalog/dependencies-query/dependencies-query-format';
 import type { OutputFormatter } from '../util/text/ansi';
 import Joi from 'joi';
-import type { LocationMapQuery } from './catalog/location-map-query/location-map-query-format';
-import type { ConfigQuery } from './catalog/config-query/config-query-format';
-import type { SearchQuery } from './catalog/search-query/search-query-format';
-import type { HappensBeforeQuery } from './catalog/happens-before-query/happens-before-query-format';
-import type { ResolveValueQuery } from './catalog/resolve-value-query/resolve-value-query-format';
-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';
-import type { LinterQuery } from './catalog/linter-query/linter-query-format';
+import { type LocationMapQuery } from './catalog/location-map-query/location-map-query-format';
+import { type ConfigQuery } from './catalog/config-query/config-query-format';
+import { type SearchQuery } from './catalog/search-query/search-query-format';
+import { type HappensBeforeQuery } from './catalog/happens-before-query/happens-before-query-format';
+import { type ResolveValueQuery } from './catalog/resolve-value-query/resolve-value-query-format';
+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';
+import { type LinterQuery } from './catalog/linter-query/linter-query-format';
 import type { NodeId } from '../r-bridge/lang-4.x/ast/model/processing/node-id';
-import type { ControlFlowQuery } from './catalog/control-flow-query/control-flow-query-format';
-import type { DfShapeQuery } from './catalog/df-shape-query/df-shape-query-format';
+import { type ControlFlowQuery } from './catalog/control-flow-query/control-flow-query-format';
+import { type DfShapeQuery } from './catalog/df-shape-query/df-shape-query-format';
 import type { AsyncOrSync } from 'ts-essentials';
 import type { FlowrConfigOptions } from '../config';
-import type { InspectHigherOrderQuery } from './catalog/inspect-higher-order-query/inspect-higher-order-query-format';
-import type { FlowrAnalysisProvider } from '../project/flowr-analyzer';
+import { type InspectHigherOrderQuery } from './catalog/inspect-higher-order-query/inspect-higher-order-query-format';
+import type { ReadonlyFlowrAnalysisProvider } from '../project/flowr-analyzer';
+import type { ReplOutput } from '../cli/repl/commands/repl-main';
+import type { CommandCompletions } from '../cli/repl/core';
 /**
  * These are all queries that can be executed from within flowR
- * {@link SynchronousQuery} are queries that can be executed synchronously, i.e., they do not return a Promise.
  */
-export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | ControlFlowQuery | DataflowLensQuery | DfShapeQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | LineageQuery | DependenciesQuery | LocationMapQuery | HappensBeforeQuery | InspectHigherOrderQuery | ResolveValueQuery | ProjectQuery | OriginQuery | LinterQuery;
+export type Query = CallContextQuery | ConfigQuery | SearchQuery | DataflowQuery | ControlFlowQuery | DataflowLensQuery | DfShapeQuery | NormalizedAstQuery | IdMapQuery | DataflowClusterQuery | StaticSliceQuery | DependenciesQuery | LocationMapQuery | HappensBeforeQuery | InspectHigherOrderQuery | ResolveValueQuery | ProjectQuery | OriginQuery | LinterQuery;
 export type QueryArgumentsWithType<QueryType extends BaseQueryFormat['type']> = Query & {
     type: QueryType;
 };
 export type QueryExecutor<Query extends BaseQueryFormat, Result extends Promise<BaseQueryResult>> = (data: BasicQueryData, query: readonly Query[]) => Result;
+/**
+ * The result of parsing a query line from, e.g., the repl.
+ */
+export interface ParsedQueryLine<QueryType extends BaseQueryFormat['type']> {
+    /** The parsed query or queries from the line. */
+    query: QueryArgumentsWithType<QueryType> | QueryArgumentsWithType<QueryType>[] | undefined;
+    /** Optional R code associated with the query. */
+    rCode?: string;
+}
 export interface SupportedQuery<QueryType extends BaseQueryFormat['type'] = BaseQueryFormat['type']> {
     executor: QueryExecutor<QueryArgumentsWithType<QueryType>, Promise<BaseQueryResult>>;
     /** optional completion in, e.g., the repl */
-    completer?: (splitLine: readonly string[], config: FlowrConfigOptions) => string[];
+    completer?: (splitLine: readonly string[], startingNewArg: boolean, config: FlowrConfigOptions) => CommandCompletions;
     /** optional query construction from an, e.g., repl line */
-    fromLine?: (splitLine: readonly string[], config: FlowrConfigOptions) => Query | Query[] | undefined;
-    asciiSummarizer: (formatter: OutputFormatter, analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, resultStrings: string[], query: readonly Query[]) => AsyncOrSync<boolean>;
+    fromLine?: (output: ReplOutput, splitLine: readonly string[], config: FlowrConfigOptions) => ParsedQueryLine<QueryType>;
+    /**
+     * Generates an ASCII summary of the query result to be printed in, e.g., the REPL.
+     * @returns whether a summary was produced (`true` if so, `false` if not, in this case a default/generic summary will be created)
+     */
+    asciiSummarizer: (formatter: OutputFormatter, analyzer: ReadonlyFlowrAnalysisProvider, queryResults: BaseQueryResult, resultStrings: string[], query: readonly Query[]) => AsyncOrSync<boolean>;
+    jsonFormatter?: (queryResults: BaseQueryResult) => object;
     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.
@@ -53,129 +67,136 @@ export interface SupportedQuery<QueryType extends BaseQueryFormat['type'] = Base
 export declare const SupportedQueries: {
     readonly 'call-context': {
         readonly executor: typeof import("./catalog/call-context-query/call-context-query-executor").executeCallContextQueries;
-        readonly asciiSummarizer: (formatter: OutputFormatter, analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
+        readonly asciiSummarizer: (formatter: OutputFormatter, analyzer: ReadonlyFlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => Promise<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, _analyzer: unknown, queryResults: BaseQueryResult, result: string[]) => true;
-        readonly completer: (partialLine: readonly string[], config: FlowrConfigOptions) => string[];
-        readonly fromLine: (line: readonly string[], _config: FlowrConfigOptions) => [ConfigQuery];
+        readonly completer: (partialLine: readonly string[], _startingNewArg: boolean, config: FlowrConfigOptions) => CommandCompletions;
+        readonly fromLine: (output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions) => ParsedQueryLine<"config">;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: () => never[];
     };
     readonly 'control-flow': {
         readonly executor: typeof import("./catalog/control-flow-query/control-flow-query-executor").executeControlFlowQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
+        readonly asciiSummarizer: (formatter: OutputFormatter, analyzer: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
     };
     readonly dataflow: {
         readonly executor: typeof import("./catalog/dataflow-query/dataflow-query-executor").executeDataflowQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, 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;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: () => never[];
     };
     readonly 'df-shape': {
         readonly executor: typeof import("./catalog/df-shape-query/df-shape-query-executor").executeDfShapeQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly jsonFormatter: (queryResults: BaseQueryResult) => object;
+        readonly fromLine: (_output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions) => ParsedQueryLine<"df-shape">;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: () => never[];
     };
     readonly 'id-map': {
         readonly executor: typeof import("./catalog/id-map-query/id-map-query-executor").executeIdMapQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, 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;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, 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;
-        readonly asciiSummarizer: (formatter: OutputFormatter, analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
+        readonly asciiSummarizer: (formatter: OutputFormatter, analyzer: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
         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;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, 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;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly fromLine: (output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions) => ParsedQueryLine<"static-slice">;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
     };
     readonly dependencies: {
         readonly executor: typeof import("./catalog/dependencies-query/dependencies-query-executor").executeDependenciesQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[], queries: readonly Query[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[], queries: readonly Query[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: (queryResults: BaseQueryResult, query: readonly Query[]) => NodeId[];
     };
     readonly 'location-map': {
         readonly executor: typeof import("./catalog/location-map-query/location-map-query-executor").executeLocationMapQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: unknown, queryResults: BaseQueryResult, result: string[]) => boolean;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: unknown, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly fromLine: (_output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions) => ParsedQueryLine<"location-map">;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: () => never[];
     };
     readonly search: {
         readonly executor: typeof import("./catalog/search-query/search-query-executor").executeSearch;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, 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;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => true;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: () => never[];
     };
     readonly 'inspect-higher-order': {
         readonly executor: typeof import("./catalog/inspect-higher-order-query/inspect-higher-order-query-executor").executeHigherOrderQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, processed: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
+        readonly asciiSummarizer: (formatter: OutputFormatter, processed: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => Promise<boolean>;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: (queryResults: BaseQueryResult) => NodeId[];
     };
     readonly 'resolve-value': {
         readonly executor: typeof import("./catalog/resolve-value-query/resolve-value-query-executor").executeResolveValueQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly fromLine: (output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions) => ParsedQueryLine<"resolve-value">;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: () => never[];
     };
     readonly project: {
         readonly executor: typeof import("./catalog/project-query/project-query-executor").executeProjectQuery;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, 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;
-        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, _analyzer: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly fromLine: (output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions) => ParsedQueryLine<"origin">;
         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, _analyzer: FlowrAnalysisProvider, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly asciiSummarizer: (formatter: OutputFormatter, analyzer: ReadonlyFlowrAnalysisProvider<import("../r-bridge/parser").KnownParser>, queryResults: BaseQueryResult, result: string[]) => true;
+        readonly completer: (line: readonly string[], startingNewArg: boolean, _config: FlowrConfigOptions) => CommandCompletions;
+        readonly fromLine: (output: ReplOutput, line: readonly string[], _config: FlowrConfigOptions) => ParsedQueryLine<"linter">;
         readonly schema: Joi.ObjectSchema<any>;
         readonly flattenInvolvedNodes: () => never[];
     };
 };
 export type SupportedQueryTypes = keyof typeof SupportedQueries;
 export type QueryResult<Type extends Query['type']> = Promise<ReturnType<typeof SupportedQueries[Type]['executor']>>;
+/**
+ * Executes a set of queries that are all of the same type.
+ * Only use this function if you are sure all queries are of the same type.
+ * Otherwise, use {@link executeQueries}.
+ */
 export declare function executeQueriesOfSameType<SpecificQuery extends Query>(data: BasicQueryData, queries: readonly SpecificQuery[]): QueryResult<SpecificQuery['type']>;
 export type QueryResults<Base extends SupportedQueryTypes = SupportedQueryTypes> = {
     readonly [QueryType in Base]: Awaited<QueryResult<QueryType>>;
@@ -184,14 +205,31 @@ type OmitFromValues<T, K extends string | number | symbol> = {
     [P in keyof T]?: Omit<T[P], K>;
 };
 export type QueryResultsWithoutMeta<Queries extends Query> = OmitFromValues<Omit<QueryResults<Queries['type']>, '.meta'>, '.meta'>;
-export type Queries<Base extends SupportedQueryTypes, VirtualArguments extends VirtualCompoundConstraint<Base> = VirtualCompoundConstraint<Base>> = readonly (QueryArgumentsWithType<Base> | VirtualQueryArgumentsWithType<Base, VirtualArguments>)[];
+export type Queries<Base extends SupportedQueryTypes = SupportedQueryTypes, VirtualArguments extends VirtualCompoundConstraint<Base> = VirtualCompoundConstraint<Base>> = readonly (QueryArgumentsWithType<Base> | VirtualQueryArgumentsWithType<Base, VirtualArguments>)[];
 /**
  * This is the main query execution function that takes a set of queries and executes them on the given data.
+ * @see {@link executeQueriesOfSameType}
+ */
+export declare function executeQueries<Base extends SupportedQueryTypes, VirtualArguments extends VirtualCompoundConstraint<Base> = VirtualCompoundConstraint<Base>>(data: BasicQueryData, queries: Queries<Base, VirtualArguments>): Promise<QueryResults<Base>>;
+/**
+ * Produces a Joi schema representing all supported queries.
  */
-export declare function executeQueries<Base extends SupportedQueryTypes, VirtualArguments extends VirtualCompoundConstraint<Base> = VirtualCompoundConstraint<Base>>(data: BasicQueryData, queries: Queries<Base, VirtualArguments>): AsyncOrSync<QueryResults<Base>>;
 export declare function SupportedQueriesSchema(): Joi.AlternativesSchema<any>;
 export declare const CompoundQuerySchema: Joi.ObjectSchema<any>;
+/**
+ * Produces a Joi schema representing all virtual queries.
+ */
 export declare function VirtualQuerySchema(): Joi.AlternativesSchema<any>;
+/**
+ * Produces a Joi schema representing any supported query (including virtual queries).
+ */
 export declare function AnyQuerySchema(): Joi.AlternativesSchema<any>;
+/**
+ * Produces a Joi schema representing an array of supported queries.
+ */
 export declare function QueriesSchema(): Joi.ArraySchema<any[]>;
+/**
+ * Wraps a function that executes a REPL query and, if it fails, checks whether there were any requests to analyze.
+ */
+export declare function genericWrapReplFailIfNoRequest<T>(fn: () => Promise<T>, output: ReplOutput, analyzer: ReadonlyFlowrAnalysisProvider): Promise<T | undefined>;
 export {};