@eagleoutice/flowr 2.2.15 → 2.3.0

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

@@ -40,10 +40,10 @@ const retriever_1 = require("../../../r-bridge/retriever");
 const cfg_1 = require("../../../util/mermaid/cfg");
 const ansi_1 = require("../../../util/text/ansi");
 const cfg_simplification_1 = require("../../../control-flow/cfg-simplification");
-async function controlflow(parser, remainingLine) {
+async function controlflow(parser, remainingLine, config) {
     return await (0, default_pipelines_1.createDataflowPipeline)(parser, {
         request: (0, retriever_1.requestFromInput)(remainingLine.trim())
-    }).allRemainingSteps();
+    }, config).allRemainingSteps();
 }
 function handleString(code) {
     return code.startsWith('"') ? JSON.parse(code) : code;
@@ -51,9 +51,9 @@ function handleString(code) {
 function formatInfo(out, type) {
     return out.formatter.format(`Copied ${type} to clipboard.`, { color: 7 /* Colors.White */, effect: ansi_1.ColorEffect.Foreground, style: 3 /* FontStyles.Italic */ });
 }
-async function produceAndPrintCfg(shell, remainingLine, output, simplifications, cfgConverter) {
-    const result = await controlflow(shell, handleString(remainingLine));
-    const cfg = (0, extract_cfg_1.extractCfg)(result.normalize, result.dataflow.graph, [...cfg_simplification_1.DefaultCfgSimplificationOrder, ...simplifications]);
+async function produceAndPrintCfg(shell, remainingLine, output, simplifications, cfgConverter, config) {
+    const result = await controlflow(shell, handleString(remainingLine), config);
+    const cfg = (0, extract_cfg_1.extractCfg)(result.normalize, config, result.dataflow.graph, [...cfg_simplification_1.DefaultCfgSimplificationOrder, ...simplifications]);
     const mermaid = cfgConverter(cfg, result.normalize);
     output.stdout(mermaid);
     try {
@@ -69,8 +69,8 @@ exports.controlflowCommand = {
     usageExample: ':controlflow',
     aliases: ['cfg', 'cf'],
     script: false,
-    fn: async (output, shell, remainingLine) => {
-        await produceAndPrintCfg(shell, remainingLine, output, [], cfg_1.cfgToMermaid);
+    fn: async ({ output, parser, remainingLine, config }) => {
+        await produceAndPrintCfg(parser, remainingLine, output, [], cfg_1.cfgToMermaid, config);
     }
 };
 exports.controlflowStarCommand = {
@@ -78,8 +78,8 @@ exports.controlflowStarCommand = {
     usageExample: ':controlflow*',
     aliases: ['cfg*', 'cf*'],
     script: false,
-    fn: async (output, shell, remainingLine) => {
-        await produceAndPrintCfg(shell, remainingLine, output, [], cfg_1.cfgToMermaidUrl);
+    fn: async ({ output, parser, remainingLine, config }) => {
+        await produceAndPrintCfg(parser, remainingLine, output, [], cfg_1.cfgToMermaidUrl, config);
     }
 };
 exports.controlflowBbCommand = {
@@ -87,8 +87,8 @@ exports.controlflowBbCommand = {
     usageExample: ':controlflowbb',
     aliases: ['cfgb', 'cfb'],
     script: false,
-    fn: async (output, shell, remainingLine) => {
-        await produceAndPrintCfg(shell, remainingLine, output, ['to-basic-blocks'], cfg_1.cfgToMermaid);
+    fn: async ({ output, parser, remainingLine, config }) => {
+        await produceAndPrintCfg(parser, remainingLine, output, ['to-basic-blocks'], cfg_1.cfgToMermaid, config);
     }
 };
 exports.controlflowBbStarCommand = {
@@ -96,8 +96,8 @@ exports.controlflowBbStarCommand = {
     usageExample: ':controlflowbb*',
     aliases: ['cfgb*', 'cfb*'],
     script: false,
-    fn: async (output, shell, remainingLine) => {
-        await produceAndPrintCfg(shell, remainingLine, output, ['to-basic-blocks'], cfg_1.cfgToMermaidUrl);
+    fn: async ({ output, parser, remainingLine, config }) => {
+        await produceAndPrintCfg(parser, remainingLine, output, ['to-basic-blocks'], cfg_1.cfgToMermaidUrl, config);
     }
 };
 //# sourceMappingURL=repl-cfg.js.map

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

@@ -50,7 +50,7 @@ exports.helpCommand = {
     script: false,
     usageExample: ':help',
     aliases: ['h', '?'],
-    fn: output => {
+    fn: ({ output }) => {
         initCommandMapping();
         output.stdout(`
 If enabled ('--r-session-access' and if using the 'r-shell' engine), you can just enter R expressions which get evaluated right away:
@@ -113,7 +113,7 @@ function getReplCommands() {
                 aliases: [],
                 script: true,
                 usageExample: `:${script} --help`,
-                fn: async (output, _s, remainingLine) => {
+                fn: async ({ output, remainingLine }) => {
                     // check if the target *module* exists in the current directory, else try two dirs up, otherwise, fail with a message
                     let path = `${__dirname}/${target}`;
                     if (!hasModule(path)) {

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

@@ -41,10 +41,10 @@ const ansi_1 = require("../../../util/text/ansi");
 /**
  * Obtain the dataflow graph using a known parser (such as the {@link RShell} or {@link TreeSitterExecutor}).
  */
-async function replGetDataflow(parser, code) {
+async function replGetDataflow(config, parser, code) {
     return await (0, default_pipelines_1.createDataflowPipeline)(parser, {
         request: (0, retriever_1.requestFromInput)(code.trim())
-    }).allRemainingSteps();
+    }, config).allRemainingSteps();
 }
 function handleString(code) {
     return code.startsWith('"') ? JSON.parse(code) : code;
@@ -57,8 +57,8 @@ exports.dataflowCommand = {
     usageExample: ':dataflow',
     aliases: ['d', 'df'],
     script: false,
-    fn: async (output, shell, remainingLine) => {
-        const result = await replGetDataflow(shell, handleString(remainingLine));
+    fn: async ({ output, parser, remainingLine, config }) => {
+        const result = await replGetDataflow(config, parser, handleString(remainingLine));
         const mermaid = (0, dfg_1.graphToMermaid)({ graph: result.dataflow.graph, includeEnvironments: false }).string;
         output.stdout(mermaid);
         try {
@@ -74,8 +74,8 @@ exports.dataflowStarCommand = {
     usageExample: ':dataflow*',
     aliases: ['d*', 'df*'],
     script: false,
-    fn: async (output, shell, remainingLine) => {
-        const result = await replGetDataflow(shell, handleString(remainingLine));
+    fn: async ({ output, parser, remainingLine, config }) => {
+        const result = await replGetDataflow(config, parser, handleString(remainingLine));
         const mermaid = (0, dfg_1.graphToMermaidUrl)(result.dataflow.graph, false);
         output.stdout(mermaid);
         try {
@@ -91,8 +91,8 @@ exports.dataflowSimplifiedCommand = {
     usageExample: ':dataflowsimple',
     aliases: ['ds', 'dfs'],
     script: false,
-    fn: async (output, shell, remainingLine) => {
-        const result = await replGetDataflow(shell, handleString(remainingLine));
+    fn: async ({ output, parser, remainingLine, config }) => {
+        const result = await replGetDataflow(config, parser, handleString(remainingLine));
         const mermaid = (0, dfg_1.graphToMermaid)({ graph: result.dataflow.graph, includeEnvironments: false, simplified: true }).string;
         output.stdout(mermaid);
         try {
@@ -108,8 +108,8 @@ exports.dataflowSimpleStarCommand = {
     usageExample: ':dataflowsimple*',
     aliases: ['ds*', 'dfs*'],
     script: false,
-    fn: async (output, shell, remainingLine) => {
-        const result = await replGetDataflow(shell, handleString(remainingLine));
+    fn: async ({ output, parser, remainingLine, config }) => {
+        const result = await replGetDataflow(config, parser, handleString(remainingLine));
         const mermaid = (0, dfg_1.graphToMermaidUrl)(result.dataflow.graph, false, undefined, true);
         output.stdout(mermaid);
         try {

package/cli/repl/commands/repl-execute.d.ts

@@ -1,4 +1,3 @@
-import type { ReplCommand, ReplOutput } from './repl-main';
-import type { KnownParser } from '../../../r-bridge/parser';
-export declare function tryExecuteRShellCommand(output: ReplOutput, parser: KnownParser, statement: string, allowRSessionAccess: boolean): Promise<void>;
+import type { ReplCommand, ReplCommandInformation } from './repl-main';
+export declare function tryExecuteRShellCommand({ output, parser, allowRSessionAccess, remainingLine }: ReplCommandInformation): Promise<void>;
 export declare const executeCommand: ReplCommand;

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

@@ -4,16 +4,16 @@ exports.executeCommand = void 0;
 exports.tryExecuteRShellCommand = tryExecuteRShellCommand;
 const ansi_1 = require("../../../util/text/ansi");
 const shell_1 = require("../../../r-bridge/shell");
-async function tryExecuteRShellCommand(output, parser, statement, allowRSessionAccess) {
+async function tryExecuteRShellCommand({ output, parser, allowRSessionAccess, remainingLine }) {
     if (!allowRSessionAccess) {
         output.stderr(`${output.formatter.format('You are not allowed to execute arbitrary R code.', { style: 1 /* FontStyles.Bold */, color: 1 /* Colors.Red */, effect: ansi_1.ColorEffect.Foreground })} 
-If you want to do so, please restart flowR with the ${output.formatter.format('--r-session-access', { style: 1 /* FontStyles.Bold */ })} flag${parser.name !== 'r-shell' ? '. Additionally, please enable the r-shell engine, e.g., with ' + output.formatter.format('--default-engine r-shell', { style: 1 /* FontStyles.Bold */ }) : ''}. Please be careful of the security implications of this action.`);
+If you want to do so, please restart flowR with the ${output.formatter.format('--r-session-access', { style: 1 /* FontStyles.Bold */ })} flag${parser.name !== 'r-shell' ? '. Additionally, please enable the r-shell engine, e.g., with ' + output.formatter.format('--default-engine r-shell', { style: 1 /* FontStyles.Bold */ }) : ''}. Please be careful of the security implications of this action. When running flowR with npm, you have to use an extra ${output.formatter.format('--', { style: 1 /* FontStyles.Bold */ })} to separate flowR from npm arguments.`);
     }
     else if (parser instanceof shell_1.RShell) {
-        await executeRShellCommand(output, parser, statement);
+        await executeRShellCommand(output, parser, remainingLine);
     }
     else {
-        output.stderr(`Executing arbitrary R code is only possible when using the r-shell engine as the default engine. Enable it using the configuration file or the ${output.formatter.format('--default-engine r-shell', { style: 1 /* FontStyles.Bold */ })} command line option.`);
+        output.stderr(`Executing arbitrary R code is only possible when using the r-shell engine as the default engine. Enable it using the configuration file or the ${output.formatter.format('--default-engine r-shell', { style: 1 /* FontStyles.Bold */ })} command line option. When running flowR with npm, you have to use an extra ${output.formatter.format('--', { style: 1 /* FontStyles.Bold */ })} to separate flowR from npm arguments.`);
     }
 }
 async function executeRShellCommand(output, shell, statement) {

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

@@ -10,10 +10,10 @@ const assert_1 = require("../../../util/assert");
 function splitAt(str, idx) {
     return [str.slice(0, idx), str.slice(idx)];
 }
-async function getDfg(parser, remainingLine) {
+async function getDfg(config, parser, remainingLine) {
     return await (0, default_pipelines_1.createDataflowPipeline)(parser, {
         request: (0, retriever_1.requestFromInput)(remainingLine.trim())
-    }).allRemainingSteps();
+    }, config).allRemainingSteps();
 }
 function filterRelevantEdges(edge) {
     return (0, edge_1.edgeIncludesType)(edge_1.EdgeType.DefinedBy | edge_1.EdgeType.DefinedByOnCall | edge_1.EdgeType.Returns | edge_1.EdgeType.Reads, edge.types);
@@ -56,9 +56,9 @@ exports.lineageCommand = {
     usageExample: ':lineage',
     aliases: ['lin'],
     script: false,
-    fn: async (output, shell, remainingLine) => {
+    fn: async ({ output, parser, remainingLine, config }) => {
         const [criterion, rest] = splitAt(remainingLine, remainingLine.indexOf(' '));
-        const { dataflow: dfg } = await getDfg(shell, rest);
+        const { dataflow: dfg } = await getDfg(config, parser, rest);
         const lineageIds = getLineage(criterion, dfg.graph);
         output.stdout([...lineageIds].join('\n'));
     }

package/cli/repl/commands/repl-main.d.ts

@@ -1,5 +1,6 @@
 import type { OutputFormatter } from '../../../util/text/ansi';
 import type { KnownParser } from '../../../r-bridge/parser';
+import type { FlowrConfigOptions } from '../../../config';
 /**
  * Defines the main interface for output of the repl.
  * This allows us to redirect it (e.g., in the case of a server connection or tests).
@@ -18,6 +19,16 @@ export interface ReplOutput {
  * @see ReplOutput
  */
 export declare const standardReplOutput: ReplOutput;
+/**
+ * Information passed to each repl command function
+ */
+export interface ReplCommandInformation {
+    output: ReplOutput;
+    parser: KnownParser;
+    remainingLine: string;
+    allowRSessionAccess: boolean;
+    config: FlowrConfigOptions;
+}
 /**
  * Content of a single command in the repl.
  * The command may execute an external script or simply call *flowR* functions.
@@ -35,5 +46,5 @@ export interface ReplCommand {
      * Function to execute when the command is invoked, it must not write to the command line but instead use the output handler.
      * Furthermore, it has to obey the formatter defined in the {@link ReplOutput}.
      */
-    fn: (output: ReplOutput, parser: KnownParser, remainingLine: string, allowRSessionAccess: boolean) => Promise<void> | void;
+    fn: (info: ReplCommandInformation) => Promise<void> | void;
 }

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

@@ -38,10 +38,10 @@ const default_pipelines_1 = require("../../../core/steps/pipeline/default-pipeli
 const retriever_1 = require("../../../r-bridge/retriever");
 const ast_1 = require("../../../util/mermaid/ast");
 const ansi_1 = require("../../../util/text/ansi");
-async function normalize(parser, remainingLine) {
+async function normalize(parser, remainingLine, config) {
     return await (0, default_pipelines_1.createNormalizePipeline)(parser, {
         request: (0, retriever_1.requestFromInput)(remainingLine.trim())
-    }).allRemainingSteps();
+    }, config).allRemainingSteps();
 }
 function handleString(code) {
     return code.startsWith('"') ? JSON.parse(code) : code;
@@ -54,8 +54,8 @@ exports.normalizeCommand = {
     usageExample: ':normalize',
     aliases: ['n'],
     script: false,
-    fn: async (output, shell, remainingLine) => {
-        const result = await normalize(shell, handleString(remainingLine));
+    fn: async ({ output, parser, remainingLine, config }) => {
+        const result = await normalize(parser, handleString(remainingLine), config);
         const mermaid = (0, ast_1.normalizedAstToMermaid)(result.normalize.ast);
         output.stdout(mermaid);
         try {
@@ -71,8 +71,8 @@ exports.normalizeStarCommand = {
     usageExample: ':normalize*',
     aliases: ['n*'],
     script: false,
-    fn: async (output, shell, remainingLine) => {
-        const result = await normalize(shell, handleString(remainingLine));
+    fn: async ({ output, parser, remainingLine, config }) => {
+        const result = await normalize(parser, handleString(remainingLine), config);
         const mermaid = (0, ast_1.normalizedAstToMermaidUrl)(result.normalize.ast);
         output.stdout(mermaid);
         try {

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

@@ -130,10 +130,10 @@ exports.parseCommand = {
     usageExample: ':parse',
     aliases: ['p'],
     script: false,
-    fn: async (output, parser, remainingLine) => {
+    fn: async ({ output, parser, remainingLine, config }) => {
         const result = await (0, default_pipelines_1.createParsePipeline)(parser, {
             request: (0, retriever_1.requestFromInput)((0, retriever_1.removeRQuotes)(remainingLine.trim()))
-        }).allRemainingSteps();
+        }, config).allRemainingSteps();
         if (parser.name === 'r-shell') {
             const object = (0, format_1.convertPreparedParsedData)((0, format_1.prepareParsedData)(result.parse.parsed));
             output.stdout(depthListToTextTree(toDepthMap(object), output.formatter));

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

@@ -9,10 +9,10 @@ const schema_1 = require("../../../util/schema");
 const query_1 = require("../../../queries/query");
 const json_1 = require("../../../util/json");
 const query_print_1 = require("../../../queries/query-print");
-async function getDataflow(parser, remainingLine) {
+async function getDataflow(config, parser, remainingLine) {
     return await (0, default_pipelines_1.createDataflowPipeline)(parser, {
         request: (0, retriever_1.requestFromInput)(remainingLine.trim())
-    }).allRemainingSteps();
+    }, config).allRemainingSteps();
 }
 function printHelp(output) {
     output.stderr(`Format: ${(0, ansi_1.italic)(':query "<query>" <code>', output.formatter)}`);
@@ -24,7 +24,7 @@ function printHelp(output) {
     output.stdout('Similarly, \'@<type>\' is interpreted as a query of the given type.');
     output.stdout(`With this, ${(0, ansi_1.italic)(':query @config', output.formatter)} prints the result of the config query.`);
 }
-async function processQueryArgs(line, parser, output) {
+async function processQueryArgs(line, parser, output, config) {
     const args = (0, args_1.splitAtEscapeSensitive)(line);
     const query = args.shift();
     if (!query) {
@@ -57,9 +57,9 @@ async function processQueryArgs(line, parser, output) {
     else {
         parsedQuery = [{ type: 'call-context', callName: query }];
     }
-    const processed = await getDataflow(parser, args.join(' '));
+    const processed = await getDataflow(config, parser, args.join(' '));
     return {
-        query: (0, query_1.executeQueries)({ dataflow: processed.dataflow, ast: processed.normalize }, parsedQuery),
+        query: (0, query_1.executeQueries)({ dataflow: processed.dataflow, ast: processed.normalize, config: config }, parsedQuery),
         processed
     };
 }
@@ -68,9 +68,9 @@ exports.queryCommand = {
     usageExample: ':query "<query>" <code>',
     aliases: [],
     script: false,
-    fn: async (output, parser, remainingLine) => {
+    fn: async ({ output, parser, remainingLine, config }) => {
         const totalStart = Date.now();
-        const results = await processQueryArgs(remainingLine, parser, output);
+        const results = await processQueryArgs(remainingLine, parser, output, config);
         const totalEnd = Date.now();
         if (results) {
             output.stdout((0, query_print_1.asciiSummaryOfQueryResult)(ansi_1.ansiFormatter, totalEnd - totalStart, results.query, results.processed));
@@ -82,8 +82,8 @@ exports.queryStarCommand = {
     usageExample: ':query* <query> <code>',
     aliases: [],
     script: false,
-    fn: async (output, shell, remainingLine) => {
-        const results = await processQueryArgs(remainingLine, shell, output);
+    fn: async ({ output, parser, remainingLine, config }) => {
+        const results = await processQueryArgs(remainingLine, parser, output, config);
         if (results) {
             output.stdout(JSON.stringify(results.query, json_1.jsonReplacer));
         }

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

@@ -24,6 +24,6 @@ exports.versionCommand = {
     aliases: [],
     usageExample: ':version',
     script: false,
-    fn: (output, parser) => printVersionInformation(output, parser)
+    fn: ({ output, parser }) => printVersionInformation(output, parser)
 };
 //# sourceMappingURL=repl-version.js.map

package/cli/repl/core.d.ts

@@ -2,6 +2,7 @@ import * as readline from 'readline';
 import type { ReplOutput } from './commands/repl-main';
 import type { MergeableRecord } from '../../util/objects';
 import type { KnownParser } from '../../r-bridge/parser';
+import type { FlowrConfigOptions } from '../../config';
 /**
  * Used by the repl to provide automatic completions for a given (partial) input line
  */
@@ -10,12 +11,13 @@ export declare function makeDefaultReplReadline(): readline.ReadLineOptions;
 /**
  * This function interprets the given `expr` as a REPL command (see {@link repl} for more on the semantics).
  *
+ * @param config              - flowr Config
  * @param output              - Defines two methods that every function in the repl uses to output its data.
  * @param expr                - The expression to process.
  * @param parser               - The {@link RShell} or {@link TreeSitterExecutor} to use (see {@link repl}).
  * @param allowRSessionAccess - If true, allows the execution of arbitrary R code.
  */
-export declare function replProcessAnswer(output: ReplOutput, expr: string, parser: KnownParser, allowRSessionAccess: boolean): Promise<void>;
+export declare function replProcessAnswer(config: FlowrConfigOptions, output: ReplOutput, expr: string, parser: KnownParser, allowRSessionAccess: boolean): Promise<void>;
 /**
  * Options for the {@link repl} function.
  */
@@ -43,9 +45,10 @@ export interface FlowrReplOptions extends MergeableRecord {
  * - 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.
+ * @param config  - The flowr config
  *
  * For the execution, this function makes use of {@link replProcessAnswer}.
  *
  */
-export declare function repl({ parser, rl, output, historyFile, allowRSessionAccess }: FlowrReplOptions): Promise<void>;
+export declare function repl(config: FlowrConfigOptions, { parser, rl, output, historyFile, allowRSessionAccess }: FlowrReplOptions): Promise<void>;
 export declare function loadReplHistory(historyFile: string): string[] | undefined;

package/cli/repl/core.js

@@ -59,6 +59,7 @@ const retriever_1 = require("../../r-bridge/retriever");
 const repl_main_1 = require("./commands/repl-main");
 const shell_1 = require("../../r-bridge/shell");
 const log_1 = require("../../util/log");
+const config_1 = require("../../config");
 let _replCompleterKeywords = undefined;
 function replCompleterKeywords() {
     if (_replCompleterKeywords === undefined) {
@@ -109,15 +110,14 @@ function makeDefaultReplReadline() {
         completer: replCompleter
     };
 }
-;
-async function replProcessStatement(output, statement, parser, allowRSessionAccess) {
+async function replProcessStatement(output, statement, parser, allowRSessionAccess, config) {
     if (statement.startsWith(':')) {
         const command = statement.slice(1).split(' ')[0].toLowerCase();
         const processor = (0, repl_commands_1.getCommand)(command);
         const bold = (s) => output.formatter.format(s, { style: 1 /* FontStyles.Bold */ });
         if (processor) {
             try {
-                await processor.fn(output, parser, statement.slice(command.length + 2).trim(), allowRSessionAccess);
+                await processor.fn({ output, parser, remainingLine: statement.slice(command.length + 2).trim(), allowRSessionAccess, config });
             }
             catch (e) {
                 output.stdout(`${bold(`Failed to execute command ${command}`)}: ${e?.message}. Using the ${bold('--verbose')} flag on startup may provide additional information.\n`);
@@ -131,21 +131,22 @@ async function replProcessStatement(output, statement, parser, allowRSessionAcce
         }
     }
     else {
-        await (0, repl_execute_1.tryExecuteRShellCommand)(output, parser, statement, allowRSessionAccess);
+        await (0, repl_execute_1.tryExecuteRShellCommand)({ output, parser, remainingLine: statement, allowRSessionAccess, config });
     }
 }
 /**
  * This function interprets the given `expr` as a REPL command (see {@link repl} for more on the semantics).
  *
+ * @param config              - flowr Config
  * @param output              - Defines two methods that every function in the repl uses to output its data.
  * @param expr                - The expression to process.
  * @param parser               - The {@link RShell} or {@link TreeSitterExecutor} to use (see {@link repl}).
  * @param allowRSessionAccess - If true, allows the execution of arbitrary R code.
  */
-async function replProcessAnswer(output, expr, parser, allowRSessionAccess) {
+async function replProcessAnswer(config, output, expr, parser, allowRSessionAccess) {
     const statements = (0, args_1.splitAtEscapeSensitive)(expr, false, ';');
     for (const statement of statements) {
-        await replProcessStatement(output, statement, parser, allowRSessionAccess);
+        await replProcessStatement(output, statement, parser, allowRSessionAccess, config);
     }
 }
 /**
@@ -156,11 +157,12 @@ async function replProcessAnswer(output, expr, parser, allowRSessionAccess) {
  * - 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.
+ * @param config  - The flowr config
  *
  * For the execution, this function makes use of {@link replProcessAnswer}.
  *
  */
-async function repl({ parser = new shell_1.RShell({ revive: 2 /* RShellReviveOptions.Always */ }), rl = readline.createInterface(makeDefaultReplReadline()), output = repl_main_1.standardReplOutput, historyFile = defaultHistoryFile, allowRSessionAccess = false }) {
+async function repl(config, { parser = new shell_1.RShell((0, config_1.getEngineConfig)(config, 'r-shell'), { revive: 2 /* RShellReviveOptions.Always */ }), rl = readline.createInterface(makeDefaultReplReadline()), 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' }));
     }
@@ -169,7 +171,7 @@ async function repl({ parser = new shell_1.RShell({ revive: 2 /* RShellReviveOpt
         await new Promise((resolve, reject) => {
             rl.question((0, prompt_1.prompt)(), answer => {
                 rl.pause();
-                replProcessAnswer(output, answer, parser, allowRSessionAccess).then(() => {
+                replProcessAnswer(config, output, answer, parser, allowRSessionAccess).then(() => {
                     rl.resume();
                     resolve();
                 }).catch(reject);

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

@@ -3,6 +3,7 @@ import { DEFAULT_SLICING_PIPELINE } from '../../../core/steps/pipeline/default-p
 import type { PipelineOutput } from '../../../core/steps/pipeline/pipeline';
 import type { DeepPartial } from 'ts-essentials';
 import type { KnownParser } from '../../../r-bridge/parser';
+import type { FlowrConfigOptions } from '../../../config';
 /**
  * Each connection handles a single client, answering to its requests.
  * There is no need to construct this class manually, {@link FlowRServer} will do it for you.
@@ -13,8 +14,9 @@ export declare class FlowRServerConnection {
     private readonly name;
     private readonly logger;
     private readonly allowRSessionAccess;
+    private readonly config;
     private readonly fileMap;
-    constructor(socket: Socket, name: string, parser: KnownParser, allowRSessionAccess: boolean);
+    constructor(socket: Socket, name: string, parser: KnownParser, allowRSessionAccess: boolean, config: FlowrConfigOptions);
     private currentMessageBuffer;
     private handleData;
     private handleFileAnalysisRequest;

package/cli/repl/server/connection.js

@@ -71,10 +71,12 @@ class FlowRServerConnection {
     name;
     logger;
     allowRSessionAccess;
+    config;
     // maps token to information
     fileMap = new Map();
     // we do not have to ensure synchronized shell-access as we are always running synchronized
-    constructor(socket, name, parser, allowRSessionAccess) {
+    constructor(socket, name, parser, allowRSessionAccess, config) {
+        this.config = config;
         this.socket = socket;
         this.parser = parser;
         this.name = name;
@@ -160,7 +162,7 @@ class FlowRServerConnection {
     async sendFileAnalysisResponse(slicer, results, message) {
         let cfg = undefined;
         if (message.cfg) {
-            cfg = (0, extract_cfg_1.extractCfg)(results.normalize, results.dataflow?.graph);
+            cfg = (0, extract_cfg_1.extractCfg)(results.normalize, this.config, results.dataflow?.graph);
         }
         const config = () => ({ context: message.filename ?? 'unknown', getId: (0, quads_1.defaultQuadIdGenerator)() });
         const sanitizedResults = sanitizeAnalysisResults(results);
@@ -222,7 +224,7 @@ class FlowRServerConnection {
         const slicer = (0, default_pipelines_1.createSlicePipeline)(this.parser, {
             request,
             criterion: [] // currently unknown
-        });
+        }, this.config);
         if (message.filetoken) {
             this.logger.info(`Storing file token ${message.filetoken}`);
             this.fileMap.set(message.filetoken, {
@@ -286,7 +288,7 @@ class FlowRServerConnection {
                 stream
             });
         };
-        void (0, core_1.replProcessAnswer)({
+        void (0, core_1.replProcessAnswer)(this.config, {
             formatter: request.ansi ? ansi_1.ansiFormatter : ansi_1.voidFormatter,
             stdout: msg => out('stdout', msg),
             stderr: msg => out('stderr', msg)
@@ -346,7 +348,7 @@ class FlowRServerConnection {
         const { dataflow: dfg, normalize: ast } = fileInformation.pipeline.getResults(true);
         (0, assert_1.guard)(dfg !== undefined, `Dataflow graph must be present (request: ${request.filetoken})`);
         (0, assert_1.guard)(ast !== undefined, `AST must be present (request: ${request.filetoken})`);
-        const results = (0, query_1.executeQueries)({ dataflow: dfg, ast }, request.query);
+        const results = (0, query_1.executeQueries)({ dataflow: dfg, ast, config: this.config }, request.query);
         (0, send_1.sendMessage)(this.socket, {
             type: 'response-query',
             id: request.id,

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

@@ -1,6 +1,6 @@
 import type { Server } from './net';
 import { FlowrLogger } from '../../../util/log';
-import type { KnownEngines } from '../../../config';
+import type { FlowrConfigOptions, KnownEngines } from '../../../config';
 export declare const serverLog: FlowrLogger;
 /**
  * This class controls the TCP server, which can be started by calling {@link start}.
@@ -13,10 +13,11 @@ export declare class FlowRServer {
     private readonly defaultEngine;
     private versionInformation;
     private readonly allowRSessionAccess;
+    private readonly config;
     /** maps names to the respective connection */
     private readonly connections;
     private nameCounter;
-    constructor(engines: KnownEngines, defaultEngine: keyof KnownEngines, allowRSessionAccess: boolean, server?: Server);
+    constructor(engines: KnownEngines, defaultEngine: keyof KnownEngines, allowRSessionAccess: boolean, config: FlowrConfigOptions, server?: Server);
     start(port: number): Promise<void>;
     private onConnect;
 }

package/cli/repl/server/server.js

@@ -19,15 +19,17 @@ class FlowRServer {
     defaultEngine;
     versionInformation;
     allowRSessionAccess;
+    config;
     /** maps names to the respective connection */
     connections = new Map();
     nameCounter = 0;
-    constructor(engines, defaultEngine, allowRSessionAccess, server = new net_1.NetServer()) {
+    constructor(engines, defaultEngine, allowRSessionAccess, config, server = new net_1.NetServer()) {
         this.server = server;
         this.server.onConnect(c => this.onConnect(c));
         this.engines = engines;
         this.defaultEngine = defaultEngine;
         this.allowRSessionAccess = allowRSessionAccess;
+        this.config = config;
     }
     async start(port) {
         this.versionInformation = await (0, repl_version_1.retrieveVersionInformation)(this.engines[this.defaultEngine]);
@@ -41,7 +43,7 @@ class FlowRServer {
         }
         const name = `client-${this.nameCounter++}`;
         exports.serverLog.info(`Client connected: ${(0, send_1.getUnnamedSocketName)(c)} as "${name}"`);
-        this.connections.set(name, new connection_1.FlowRServerConnection(c, name, this.engines[this.defaultEngine], this.allowRSessionAccess));
+        this.connections.set(name, new connection_1.FlowRServerConnection(c, name, this.engines[this.defaultEngine], this.allowRSessionAccess, this.config));
         helloClient(c, name, this.versionInformation);
         c.on('close', () => {
             this.connections.delete(name);

package/cli/script-core/statistics-core.d.ts

@@ -1,2 +1,3 @@
 import type { StatsCliOptions } from '../statistics-app';
-export declare function flowrScriptGetStats(options: StatsCliOptions): Promise<void>;
+import type { FlowrConfigOptions } from '../../config';
+export declare function flowrScriptGetStats(options: StatsCliOptions, config: FlowrConfigOptions): Promise<void>;

package/cli/script-core/statistics-core.js

@@ -57,7 +57,7 @@ async function collectFileArguments(options, verboseAdd, dumpJson, features) {
     console.log(`Total: ${counter} files (${skipped} skipped with archive existing)`);
     return files;
 }
-async function flowrScriptGetStats(options) {
+async function flowrScriptGetStats(options, config) {
     if (options.input.length === 0) {
         console.error('No input files given. Nothing to do. See \'--help\' if this is an error.');
         process.exit(0);
@@ -93,7 +93,7 @@ async function flowrScriptGetStats(options) {
     else {
         console.log('Run Sequentially as parallel <= 0...');
         for (const arg of args) {
-            await (0, statistics_helper_core_1.getStatsForSingleFile)((0, command_line_args_1.default)(scripts_info_1.scripts['stats-helper'].options, { argv: arg }));
+            await (0, statistics_helper_core_1.getStatsForSingleFile)((0, command_line_args_1.default)(scripts_info_1.scripts['stats-helper'].options, { argv: arg }), config);
         }
     }
 }

package/cli/script-core/statistics-helper-core.d.ts

@@ -1,2 +1,3 @@
 import type { StatsHelperCliOptions } from '../statistics-helper-app';
-export declare function getStatsForSingleFile(options: StatsHelperCliOptions): Promise<void>;
+import type { FlowrConfigOptions } from '../../config';
+export declare function getStatsForSingleFile(options: StatsHelperCliOptions, config: FlowrConfigOptions): Promise<void>;