@eagleoutice/flowr 2.6.1 → 2.6.3

package/cli/repl/commands/repl-parse.js

@@ -4,6 +4,7 @@ exports.parseCommand = void 0;
 const format_1 = require("../../../r-bridge/lang-4.x/ast/parser/json/format");
 const normalize_meta_1 = require("../../../r-bridge/lang-4.x/ast/parser/main/normalize-meta");
 const retriever_1 = require("../../../r-bridge/retriever");
+const flowr_file_1 = require("../../../project/context/flowr-file");
 function toDepthMap(entry) {
     const visit = [{ depth: 0, node: entry }];
     const result = [];
@@ -133,20 +134,31 @@ exports.parseCommand = {
     argsParser: (line) => {
         return {
             // Threat the whole input line as R code
-            input: (0, retriever_1.removeRQuotes)(line.trim()),
+            rCode: (0, retriever_1.removeRQuotes)(line.trim()),
             remaining: []
         };
     },
     fn: async ({ output, analyzer }) => {
-        const result = await analyzer.parse();
-        const parserInfo = await analyzer.parserInformation();
+        const result = (await analyzer.parse()).files;
+        const parserInfo = analyzer.parserInformation();
         if (parserInfo.name === 'r-shell') {
-            const object = (0, format_1.convertPreparedParsedData)((0, format_1.prepareParsedData)(result.parsed));
-            output.stdout(depthListToTextTree(toDepthMap(object), output.formatter));
+            for (const { parsed, filePath } of result) {
+                if (filePath && filePath !== flowr_file_1.FlowrFile.INLINE_PATH) {
+                    output.stdout(output.formatter.format(`File: ${filePath}\n`, { style: 4 /* FontStyles.Underline */ }));
+                }
+                const object = toDepthMap((0, format_1.convertPreparedParsedData)((0, format_1.prepareParsedData)(parsed)));
+                output.stdout(depthListToTextTree(object, output.formatter));
+            }
         }
         else {
             // print the tree-sitter ast
-            output.stdout(depthListToTextTree(treeSitterToDepthList(result.parsed.rootNode), output.formatter));
+            for (const { parsed, filePath } of result) {
+                if (filePath && filePath !== flowr_file_1.FlowrFile.INLINE_PATH) {
+                    output.stdout(output.formatter.format(`File: ${filePath}\n`, { style: 4 /* FontStyles.Underline */ }));
+                }
+                const object = treeSitterToDepthList(parsed.rootNode);
+                output.stdout(depthListToTextTree(object, output.formatter));
+            }
         }
     }
 };

package/cli/repl/commands/repl-query.js

@@ -29,15 +29,19 @@ async function processQueryArgs(output, analyzer, remainingArgs) {
         return;
     }
     let parsedQuery;
+    let input;
     if (query.startsWith('@')) {
         const queryName = query.slice(1);
         const queryObj = query_1.SupportedQueries[queryName];
         if (queryObj?.fromLine) {
-            const q = queryObj.fromLine(remainingArgs, analyzer.flowrConfig);
+            const parseResult = queryObj.fromLine(output, remainingArgs, analyzer.flowrConfig);
+            const q = parseResult.query;
             parsedQuery = q ? (Array.isArray(q) ? q : [q]) : [];
+            input = parseResult.rCode;
         }
         else {
             parsedQuery = [{ type: query.slice(1) }];
+            input = remainingArgs.join(' ').trim();
         }
         const validationResult = (0, query_1.QueriesSchema)().validate(parsedQuery);
         if (validationResult.error) {
@@ -54,10 +58,15 @@ async function processQueryArgs(output, analyzer, remainingArgs) {
             printHelp(output);
             return;
         }
+        input = remainingArgs.join(' ').trim();
     }
     else {
         parsedQuery = [{ type: 'call-context', callName: query }];
     }
+    if (input) {
+        analyzer.reset();
+        analyzer.addRequest(input);
+    }
     return {
         query: await (0, query_1.executeQueries)({
             analyzer,
@@ -68,13 +77,13 @@ async function processQueryArgs(output, analyzer, remainingArgs) {
 }
 /**
  * Function for splitting the input line.
- * The first token is the query command.
- * The rest of the line is treated as input code.
+ * All input is treated as arguments, no R code is separated so that the individual queries can handle it.
+ * @param line - The input line
  */
 function parseArgs(line) {
     const args = (0, args_1.splitAtEscapeSensitive)(line);
     return {
-        input: args[1].trim() === 'help' ? '' : args.slice(1).join(' ').trim(),
+        rCode: undefined,
         remaining: args
     };
 }
@@ -104,7 +113,9 @@ exports.queryStarCommand = {
     fn: async ({ output, analyzer, remainingArgs }) => {
         const results = await processQueryArgs(output, analyzer, remainingArgs);
         if (results) {
-            output.stdout(JSON.stringify(results.query, json_1.jsonReplacer));
+            const json = Object.fromEntries(Object.entries(results.query)
+                .map(([query, queryResults]) => [query, query_1.SupportedQueries[query]?.jsonFormatter?.(queryResults) ?? queryResults]));
+            output.stdout(JSON.stringify(json, json_1.jsonReplacer));
         }
     }
 };

package/cli/repl/core.d.ts

@@ -1,20 +1,37 @@
 import * as readline from 'readline';
-import type { ReplOutput } from './commands/repl-main';
+import { type ReplOutput } from './commands/repl-main';
 import type { MergeableRecord } from '../../util/objects';
 import type { FlowrConfigOptions } from '../../config';
 import type { FlowrAnalyzer } from '../../project/flowr-analyzer';
+/**
+ * Completion suggestions for a specific REPL command
+ */
+export interface CommandCompletions {
+    /** The possible completions for the current argument */
+    readonly completions: string[];
+    /**
+     * The current argument fragment being completed, if any.
+     * This is relevant if an argument is composed of multiple parts (e.g. comma-separated lists).
+     */
+    readonly argumentPart?: string;
+}
 /**
  * Used by the repl to provide automatic completions for a given (partial) input line
  */
 export declare function replCompleter(line: string, config: FlowrConfigOptions): [string[], string];
+/**
+ * Produces default readline options for the flowR REPL
+ */
 export declare function makeDefaultReplReadline(config: FlowrConfigOptions): readline.ReadLineOptions;
+/**
+ * Handles a string input for the REPL, returning the parsed string and any remaining input.
+ */
 export declare function handleString(code: string): {
-    input: string | undefined;
+    rCode: string | undefined;
     remaining: never[];
 };
 /**
  * This function interprets the given `expr` as a REPL command (see {@link repl} for more on the semantics).
- *
  * @param analyzer            - The flowR analyzer to use.
  * @param output              - Defines two methods that every function in the repl uses to output its data.
  * @param expr                - The expression to process.
@@ -31,7 +48,7 @@ export interface FlowrReplOptions extends MergeableRecord {
     readonly analyzer: FlowrAnalyzer;
     /**
      * A potentially customized readline interface to be used for the repl to *read* from the user, we write the output with the {@link ReplOutput | `output` } interface.
-    * If you want to provide a custom one but use the same `completer`, refer to {@link replCompleter}.
+     * If you want to provide a custom one but use the same `completer`, refer to {@link replCompleter}.
      */
     readonly rl?: readline.Interface;
     /** Defines two methods that every function in the repl uses to output its data. */
@@ -47,11 +64,12 @@ export interface FlowrReplOptions extends MergeableRecord {
  * The repl allows for two kinds of inputs:
  * - Starting with a colon `:`, indicating a command (probe `:help`, and refer to {@link commands}) </li>
  * - Starting with anything else, indicating default R code to be directly executed. If you kill the underlying shell, that is on you! </li>
- *
  * @param options - The options for the repl. See {@link FlowrReplOptions} for more information.
  *
  * For the execution, this function makes use of {@link replProcessAnswer}.
- *
  */
 export declare function repl({ analyzer, rl, output, historyFile, allowRSessionAccess }: FlowrReplOptions): Promise<void>;
+/**
+ * Loads the REPL history from the given file.
+ */
 export declare function loadReplHistory(historyFile: string): string[] | undefined;

package/cli/repl/core.js

@@ -44,7 +44,6 @@ exports.repl = repl;
 exports.loadReplHistory = loadReplHistory;
 /**
  * Basically a helper file to allow the main 'flowr' script (located in the source root) to provide its repl
- *
  * @module
  */
 const prompt_1 = require("./prompt");
@@ -60,6 +59,7 @@ const retriever_1 = require("../../r-bridge/retriever");
 const repl_main_1 = require("./commands/repl-main");
 const log_1 = require("../../util/log");
 const query_1 = require("../../queries/query");
+const strings_1 = require("../../util/text/strings");
 let _replCompleterKeywords = undefined;
 function replCompleterKeywords() {
     if (_replCompleterKeywords === undefined) {
@@ -79,44 +79,50 @@ function replCompleter(line, config) {
     if (splitLine.length > 1 || startingNewArg) {
         const commandNameColon = replCompleterKeywords().find(k => splitLine[0] === k);
         if (commandNameColon) {
-            const completions = [];
+            let completions = [];
+            let currentArg = startingNewArg ? '' : splitLine[splitLine.length - 1];
             const commandName = commandNameColon.slice(1);
             const cmd = (0, repl_commands_1.getCommand)(commandName);
             if (cmd?.script === true) {
                 // autocomplete script arguments
                 const options = scripts_info_1.scripts[commandName].options;
-                completions.push(...(0, scripts_info_1.getValidOptionsForCompletion)(options, splitLine).map(o => `${o} `));
+                completions = completions.concat((0, scripts_info_1.getValidOptionsForCompletion)(options, splitLine).map(o => `${o} `));
             }
             else if (commandName.startsWith('query')) {
-                completions.push(...replQueryCompleter(splitLine, config));
+                const { completions: queryCompletions, argumentPart: splitArg } = replQueryCompleter(splitLine, startingNewArg, config);
+                if (splitArg !== undefined) {
+                    currentArg = splitArg;
+                }
+                completions = completions.concat(queryCompletions);
             }
             else {
                 // autocomplete command arguments (specifically, autocomplete the file:// protocol)
                 completions.push(retriever_1.fileProtocol);
             }
-            const currentArg = startingNewArg ? '' : splitLine[splitLine.length - 1];
             return [completions.filter(a => a.startsWith(currentArg)), currentArg];
         }
     }
     // if no command is already typed, just return all commands that match
     return [replCompleterKeywords().filter(k => k.startsWith(line)).map(k => `${k} `), line];
 }
-function replQueryCompleter(splitLine, config) {
+function replQueryCompleter(splitLine, startingNewArg, config) {
     const nonEmpty = splitLine.slice(1).map(s => s.trim()).filter(s => s.length > 0);
     const queryShorts = Object.keys(query_1.SupportedQueries).map(q => `@${q}`).concat(['help']);
-    let candidates = [];
-    if (nonEmpty.length == 0 || (nonEmpty.length == 1 && queryShorts.some(q => q.startsWith(nonEmpty[0]) && nonEmpty[0] !== q))) {
-        candidates = candidates.concat(queryShorts.map(q => `${q} `));
+    if (nonEmpty.length == 0 || (nonEmpty.length == 1 && queryShorts.some(q => q.startsWith(nonEmpty[0]) && nonEmpty[0] !== q && !startingNewArg))) {
+        return { completions: queryShorts.map(q => `${q} `) };
     }
     else {
         const q = nonEmpty[0].slice(1);
         const queryElement = query_1.SupportedQueries[q];
         if (queryElement?.completer) {
-            candidates = candidates.concat(queryElement.completer(nonEmpty.slice(1), config));
+            return queryElement.completer(nonEmpty.slice(1), startingNewArg, config);
         }
     }
-    return candidates;
+    return { completions: [] };
 }
+/**
+ * Produces default readline options for the flowR REPL
+ */
 function makeDefaultReplReadline(config) {
     return {
         input: process.stdin,
@@ -128,9 +134,12 @@ function makeDefaultReplReadline(config) {
         completer: (c) => replCompleter(c, config)
     };
 }
+/**
+ * Handles a string input for the REPL, returning the parsed string and any remaining input.
+ */
 function handleString(code) {
     return {
-        input: code.length == 0 ? undefined : code.startsWith('"') ? JSON.parse(code) : code,
+        rCode: code.length == 0 ? undefined : (0, strings_1.startAndEndsWith)(code, '"') ? JSON.parse(code) : code,
         remaining: []
     };
 }
@@ -141,28 +150,30 @@ async function replProcessStatement(output, statement, analyzer, allowRSessionAc
         const bold = (s) => output.formatter.format(s, { style: 1 /* FontStyles.Bold */ });
         if (processor) {
             try {
-                const remainingLine = statement.slice(command.length + 2).trim();
-                if (processor.isCodeCommand) {
-                    const args = processor.argsParser(remainingLine);
-                    if (args.input) {
-                        analyzer.reset();
-                        analyzer.context().addRequest((0, retriever_1.requestFromInput)(args.input));
+                await (0, query_1.genericWrapReplFailIfNoRequest)(async () => {
+                    const remainingLine = statement.slice(command.length + 2).trim();
+                    if (processor.isCodeCommand) {
+                        const args = processor.argsParser(remainingLine);
+                        if (args.rCode) {
+                            analyzer.reset();
+                            analyzer.addRequest(args.rCode);
+                        }
+                        await processor.fn({ output, analyzer, remainingArgs: args.remaining });
                     }
-                    await processor.fn({ output, analyzer, remainingArgs: args.remaining });
-                }
-                else {
-                    await processor.fn({ output, analyzer, remainingLine, allowRSessionAccess });
-                }
+                    else {
+                        await processor.fn({ output, analyzer, remainingLine, allowRSessionAccess });
+                    }
+                }, output, analyzer);
             }
             catch (e) {
-                output.stdout(`${bold(`Failed to execute command ${command}`)}: ${e?.message}. Using the ${bold('--verbose')} flag on startup may provide additional information.\n`);
+                output.stderr(`${bold(`Failed to execute command ${command}`)}: ${e?.message}. Using the ${bold('--verbose')} flag on startup may provide additional information.\n`);
                 if (log_1.log.settings.minLevel < 6 /* LogLevel.Fatal */) {
                     console.error(e);
                 }
             }
         }
         else {
-            output.stdout(`the command '${command}' is unknown, try ${bold(':help')} for more information\n`);
+            output.stderr(`the command '${command}' is unknown, try ${bold(':help')} for more information\n`);
         }
     }
     else {
@@ -171,16 +182,15 @@ async function replProcessStatement(output, statement, analyzer, allowRSessionAc
 }
 /**
  * This function interprets the given `expr` as a REPL command (see {@link repl} for more on the semantics).
- *
  * @param analyzer            - The flowR analyzer to use.
  * @param output              - Defines two methods that every function in the repl uses to output its data.
  * @param expr                - The expression to process.
  * @param allowRSessionAccess - If true, allows the execution of arbitrary R code.
  */
 async function replProcessAnswer(analyzer, output, expr, allowRSessionAccess) {
-    const statements = (0, args_1.splitAtEscapeSensitive)(expr, false, ';');
+    const statements = (0, args_1.splitAtEscapeSensitive)(expr, false, /^;\s*:/);
     for (const statement of statements) {
-        await replProcessStatement(output, statement, analyzer, allowRSessionAccess);
+        await replProcessStatement(output, statement.trim(), analyzer, allowRSessionAccess);
     }
 }
 /**
@@ -189,17 +199,16 @@ async function replProcessAnswer(analyzer, output, expr, allowRSessionAccess) {
  * The repl allows for two kinds of inputs:
  * - Starting with a colon `:`, indicating a command (probe `:help`, and refer to {@link commands}) </li>
  * - Starting with anything else, indicating default R code to be directly executed. If you kill the underlying shell, that is on you! </li>
- *
  * @param options - The options for the repl. See {@link FlowrReplOptions} for more information.
  *
  * For the execution, this function makes use of {@link replProcessAnswer}.
- *
  */
 async function repl({ analyzer, rl = readline.createInterface(makeDefaultReplReadline(analyzer.flowrConfig)), output = repl_main_1.standardReplOutput, historyFile = defaultHistoryFile, allowRSessionAccess = false }) {
     if (historyFile) {
         rl.on('history', h => fs_1.default.writeFileSync(historyFile, h.join('\n'), { encoding: 'utf-8' }));
     }
     // the incredible repl :D, we kill it with ':quit'
+    // noinspection InfiniteLoopJS
     while (true) {
         await new Promise((resolve, reject) => {
             rl.question((0, prompt_1.prompt)(), answer => {
@@ -212,6 +221,9 @@ async function repl({ analyzer, rl = readline.createInterface(makeDefaultReplRea
         });
     }
 }
+/**
+ * Loads the REPL history from the given file.
+ */
 function loadReplHistory(historyFile) {
     try {
         if (!fs_1.default.existsSync(historyFile)) {

package/cli/repl/execute.d.ts

@@ -3,7 +3,6 @@ type Stdio = [stdin: Writable | null, stdout: Readable | null, stderr: Readable
 export type StdioProcessor = (stdio: Stdio) => void;
 /**
  * Simply captures the output of the script executed by {@link waitOnScript}.
- *
  * @param stdio        - The standard io tuple provided by {@link waitOnScript}
  * @param onStdOutLine - The callback is executed each time we receive a new line from the standard output channel.
  * @param onStdErrLine - The callback is executed each time we receive a new line from the standard error channel.
@@ -11,7 +10,6 @@ export type StdioProcessor = (stdio: Stdio) => void;
 export declare function stdioCaptureProcessor(stdio: Stdio, onStdOutLine: (msg: string) => void, onStdErrLine: (msg: string) => void): void;
 /**
  * Run the given module with the presented arguments, and wait for it to exit.
- *
  * @param module      - The (flowR) module that you want to use for the fork.
  *                      It is probably best to use {@link __dirname} so you can specify the module relative to your
  *                      current one.

package/cli/repl/execute.js

@@ -11,7 +11,6 @@ const assert_1 = require("../../util/assert");
 const log_1 = require("../../util/log");
 /**
  * Simply captures the output of the script executed by {@link waitOnScript}.
- *
  * @param stdio        - The standard io tuple provided by {@link waitOnScript}
  * @param onStdOutLine - The callback is executed each time we receive a new line from the standard output channel.
  * @param onStdErrLine - The callback is executed each time we receive a new line from the standard error channel.
@@ -32,7 +31,6 @@ function stdioCaptureProcessor(stdio, onStdOutLine, onStdErrLine) {
 }
 /**
  * Run the given module with the presented arguments, and wait for it to exit.
- *
  * @param module      - The (flowR) module that you want to use for the fork.
  *                      It is probably best to use {@link __dirname} so you can specify the module relative to your
  *                      current one.

package/cli/repl/parser/slice-query-parser.d.ts

@@ -0,0 +1,14 @@
+import { SliceDirection } from '../../../core/steps/all/static-slicing/00-slice';
+import type { SingleSlicingCriterion, SlicingCriteria } from '../../../slicing/criterion/parse';
+/**
+ * Checks whether the given argument represents a slicing direction with an `f` suffix.
+ */
+export declare function sliceDirectionParser(argument: string): SliceDirection;
+/**
+ * Parses a single slicing criterion from the given argument.
+ */
+export declare function sliceCriterionParser(argument: string | undefined): SingleSlicingCriterion | undefined;
+/**
+ * Parses multiple slicing criteria from the given argument.
+ */
+export declare function sliceCriteriaParser(argument: string | undefined): SlicingCriteria | undefined;

package/cli/repl/parser/slice-query-parser.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sliceDirectionParser = sliceDirectionParser;
+exports.sliceCriterionParser = sliceCriterionParser;
+exports.sliceCriteriaParser = sliceCriteriaParser;
+const _00_slice_1 = require("../../../core/steps/all/static-slicing/00-slice");
+/**
+ * Checks whether the given argument represents a slicing direction with an `f` suffix.
+ */
+function sliceDirectionParser(argument) {
+    const endBracket = argument.indexOf(')');
+    return argument[endBracket + 1] === 'f' ? _00_slice_1.SliceDirection.Forward : _00_slice_1.SliceDirection.Backward;
+}
+/**
+ * Parses a single slicing criterion from the given argument.
+ */
+function sliceCriterionParser(argument) {
+    if (argument?.startsWith('(') && argument.includes(')')) {
+        const endBracket = argument.indexOf(')');
+        return argument.slice(1, endBracket);
+    }
+}
+/**
+ * Parses multiple slicing criteria from the given argument.
+ */
+function sliceCriteriaParser(argument) {
+    if (argument?.startsWith('(') && argument.includes(')')) {
+        const endBracket = argument.indexOf(')');
+        const criteriaPart = argument.slice(1, endBracket);
+        const criteria = criteriaPart.split(';');
+        return criteria;
+    }
+}
+//# sourceMappingURL=slice-query-parser.js.map

package/cli/repl/print-version.d.ts

@@ -1,3 +1,9 @@
 import type { KnownParser } from '../../r-bridge/parser';
+/**
+ * Returns a version string for the REPL including flowR and R version.
+ */
 export declare function versionReplString(parser: KnownParser): Promise<string>;
+/**
+ * Prints the version information for the REPL including flowR and R version.
+ */
 export declare function printVersionRepl(parser: KnownParser): Promise<void>;

package/cli/repl/print-version.js

@@ -3,12 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.versionReplString = versionReplString;
 exports.printVersionRepl = printVersionRepl;
 const version_1 = require("../../util/version");
+/**
+ * Returns a version string for the REPL including flowR and R version.
+ */
 async function versionReplString(parser) {
     const version = await (0, version_1.retrieveVersionInformation)(parser);
     const rVersion = version.r === 'none' ? '' : version.r === 'unknown' ? ', R version unknown' : `, R v${version.r}`;
     const treeSitterVer = parser.name === 'tree-sitter' ? `, R grammar v${parser.treeSitterVersion()}` : '';
     return `flowR repl using flowR v${version.flowr}${rVersion}${treeSitterVer} (${version.engine} engine)`;
 }
+/**
+ * Prints the version information for the REPL including flowR and R version.
+ */
 async function printVersionRepl(parser) {
     console.log(await versionReplString(parser));
 }

package/cli/repl/server/compact.d.ts

@@ -1,2 +1,10 @@
+/**
+ * Compacts an object into a UTF-16 compressed string.
+ * @see {@link uncompact}
+ */
 export declare function compact(obj: unknown): string;
+/**
+ * Uncompacts a UTF-16 compressed string into an object.
+ * @see {@link compact}
+ */
 export declare function uncompact(buf: string): unknown;

package/cli/repl/server/compact.js

@@ -4,9 +4,17 @@ exports.compact = compact;
 exports.uncompact = uncompact;
 const json_1 = require("../../../util/json");
 const lz_string_1 = require("lz-string");
+/**
+ * Compacts an object into a UTF-16 compressed string.
+ * @see {@link uncompact}
+ */
 function compact(obj) {
     return (0, lz_string_1.compressToUTF16)(JSON.stringify(obj, json_1.jsonReplacer));
 }
+/**
+ * Uncompacts a UTF-16 compressed string into an object.
+ * @see {@link compact}
+ */
 function uncompact(buf) {
     return JSON.parse((0, lz_string_1.decompressFromUTF16)(buf));
 }

package/cli/repl/server/connection.d.ts

@@ -1,6 +1,5 @@
 import type { Socket } from './net';
-import type { TREE_SITTER_DATAFLOW_PIPELINE } from '../../../core/steps/pipeline/default-pipelines';
-import { DEFAULT_SLICING_PIPELINE } from '../../../core/steps/pipeline/default-pipelines';
+import { type TREE_SITTER_DATAFLOW_PIPELINE, DEFAULT_SLICING_PIPELINE } from '../../../core/steps/pipeline/default-pipelines';
 import type { PipelineOutput } from '../../../core/steps/pipeline/pipeline';
 import type { DeepPartial } from 'ts-essentials';
 import type { KnownParser, ParseStepOutput } from '../../../r-bridge/parser';
@@ -28,7 +27,9 @@ export declare class FlowRServerConnection {
     private createAnalyzerForRequest;
     private handleSliceRequest;
     private handleRepl;
-    private handleLineageRequest;
     private handleQueryRequest;
 }
+/**
+ * Sanitizes analysis results by removing any potentially sensitive information like id maps.
+ */
 export declare function sanitizeAnalysisResults(parse: ParseStepOutput<string | Tree>, normalize: NormalizedAst, dataflow: DataflowInformation): DeepPartial<PipelineOutput<typeof DEFAULT_SLICING_PIPELINE | typeof TREE_SITTER_DATAFLOW_PIPELINE>>;

package/cli/repl/server/connection.js

@@ -56,8 +56,6 @@ const default_pipelines_1 = require("../../../core/steps/pipeline/default-pipeli
 const graph_1 = require("../../../dataflow/graph/graph");
 const tmp = __importStar(require("tmp"));
 const fs_1 = __importDefault(require("fs"));
-const message_lineage_1 = require("./messages/message-lineage");
-const repl_lineage_1 = require("../commands/repl-lineage");
 const message_query_1 = require("./messages/message-query");
 const compact_1 = require("./compact");
 const _00_slice_1 = require("../../../core/steps/all/static-slicing/00-slice");
@@ -116,9 +114,6 @@ class FlowRServerConnection {
             case 'request-repl-execution':
                 this.handleRepl(request.message);
                 break;
-            case 'request-lineage':
-                void this.handleLineageRequest(request.message);
-                break;
             case 'request-query':
                 this.handleQueryRequest(request.message);
                 break;
@@ -219,10 +214,11 @@ class FlowRServerConnection {
         else {
             throw new Error('Either content or filepath must be defined.');
         }
-        const analyzer = await new flowr_analyzer_builder_1.FlowrAnalyzerBuilder(request)
+        const analyzer = await new flowr_analyzer_builder_1.FlowrAnalyzerBuilder()
             .setConfig(this.config)
             .setParser(this.parser)
             .build();
+        analyzer.addRequest(request);
         if (message.filetoken) {
             this.logger.info(`Storing file token ${message.filetoken}`);
             this.fileMap.set(message.filetoken, {
@@ -302,32 +298,6 @@ class FlowRServerConnection {
             });
         });
     }
-    async handleLineageRequest(base) {
-        const requestResult = (0, validate_1.validateMessage)(base, message_lineage_1.requestLineageMessage);
-        if (requestResult.type === 'error') {
-            (0, validate_1.answerForValidationError)(this.socket, requestResult, base.id);
-            return;
-        }
-        const request = requestResult.message;
-        this.logger.info(`[${this.name}] Received lineage request for criterion ${request.criterion}`);
-        const fileInformation = this.fileMap.get(request.filetoken);
-        if (!fileInformation) {
-            (0, send_1.sendMessage)(this.socket, {
-                id: request.id,
-                type: 'error',
-                fatal: false,
-                reason: `The file token ${request.filetoken} has never been analyzed.`
-            });
-            return;
-        }
-        const analyzer = fileInformation.analyzer;
-        const lineageIds = (0, repl_lineage_1.getLineage)(request.criterion, (await analyzer.dataflow()).graph, (await analyzer.normalize()).idMap);
-        (0, send_1.sendMessage)(this.socket, {
-            type: 'response-lineage',
-            id: request.id,
-            lineage: [...lineageIds]
-        });
-    }
     handleQueryRequest(base) {
         const requestResult = (0, validate_1.validateMessage)(base, message_query_1.requestQueryMessage);
         if (requestResult.type === 'error') {
@@ -364,6 +334,9 @@ class FlowRServerConnection {
     }
 }
 exports.FlowRServerConnection = FlowRServerConnection;
+/**
+ * Sanitizes analysis results by removing any potentially sensitive information like id maps.
+ */
 function sanitizeAnalysisResults(parse, normalize, dataflow) {
     return {
         parse: parse,

package/cli/repl/server/messages/all-messages.d.ts

@@ -1,6 +1,5 @@
 /**
  * Provides the capability of connecting to the repl of flowr via messages.
- *
  * @module
  */
 import * as Joi from 'joi';
@@ -9,7 +8,6 @@ import type { FileAnalysisRequestMessage, FileAnalysisResponseMessageJson } from
 import type { ExecuteEndMessage, ExecuteIntermediateResponseMessage, ExecuteRequestMessage } from './message-repl';
 import type { SliceRequestMessage, SliceResponseMessage } from './message-slice';
 import type { FlowrErrorMessage } from './message-error';
-import type { LineageRequestMessage, LineageResponseMessage } from './message-lineage';
 import type { QueryRequestMessage, QueryResponseMessage } from './message-query';
 /**
  * If you send a message it must *not* contain a newline but the message must be terminated by a newline.
@@ -34,4 +32,4 @@ export declare const baseMessage: MessageDefinition<IdMessageBase>;
 /**
  * This is the main message type that should be used to represent a message in *flowR*
  */
-export type FlowrMessage = FlowrHelloResponseMessage | FileAnalysisRequestMessage | FileAnalysisResponseMessageJson | ExecuteRequestMessage | ExecuteIntermediateResponseMessage | ExecuteEndMessage | SliceRequestMessage | SliceResponseMessage | LineageRequestMessage | LineageResponseMessage | QueryRequestMessage | QueryResponseMessage | FlowrErrorMessage;
+export type FlowrMessage = FlowrHelloResponseMessage | FileAnalysisRequestMessage | FileAnalysisResponseMessageJson | ExecuteRequestMessage | ExecuteIntermediateResponseMessage | ExecuteEndMessage | SliceRequestMessage | SliceResponseMessage | QueryRequestMessage | QueryResponseMessage | FlowrErrorMessage;

package/cli/repl/server/messages/all-messages.js

@@ -36,7 +36,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.baseMessage = void 0;
 /**
  * Provides the capability of connecting to the repl of flowr via messages.
- *
  * @module
  */
 const Joi = __importStar(require("joi"));

package/cli/repl/server/messages/message-analysis.d.ts

@@ -42,9 +42,7 @@ export declare const requestAnalysisMessage: MessageDefinition<FileAnalysisReque
  *
  * The `idMap` of the normalization step (see {@link NormalizedAst}) is not serialized as it would essentially
  * repeat the complete normalized AST, you have to re-create it yourself if you require it.
- *
  * @note The serialization of maps and sets is controlled by the {@link jsonReplacer} as part of {@link sendMessage}.
- *
  * @see {@link FileAnalysisResponseMessageNQuads}
  * @see {@link FileAnalysisResponseMessageCompact}
  */

package/cli/repl/server/messages/message-query.d.ts

@@ -1,5 +1,5 @@
 import type { IdMessageBase, MessageDefinition } from './all-messages';
-import type { Queries, QueryResults, SupportedQueryTypes } from '../../../../queries/query';
+import { type Queries, type QueryResults, type SupportedQueryTypes } from '../../../../queries/query';
 export interface QueryRequestMessage extends IdMessageBase {
     type: 'request-query';
     /** The {@link FileAnalysisRequestMessage#filetoken} of the file/data */