@eagleoutice/flowr 2.4.8 → 2.6.0

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

@@ -34,88 +34,85 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dataflowSimpleStarCommand = exports.dataflowSimplifiedCommand = exports.dataflowStarCommand = exports.dataflowCommand = void 0;
-const default_pipelines_1 = require("../../../core/steps/pipeline/default-pipelines");
 const retriever_1 = require("../../../r-bridge/retriever");
 const dfg_1 = require("../../../util/mermaid/dfg");
 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(config, parser, code) {
-    return await (0, default_pipelines_1.createDataflowPipeline)(parser, {
-        request: (0, retriever_1.requestFromInput)(code.trim())
-    }, config).allRemainingSteps();
-}
-function handleString(code) {
-    return code.startsWith('"') ? JSON.parse(code) : code;
-}
-function formatInfo(out, type, timing) {
-    return out.formatter.format(`Copied ${type} to clipboard (dataflow: ${timing}ms).`, { color: 7 /* Colors.White */, effect: ansi_1.ColorEffect.Foreground, style: 3 /* FontStyles.Italic */ });
+const core_1 = require("../core");
+function formatInfo(out, type, meta) {
+    return out.formatter.format(`Copied ${type} to clipboard (dataflow: ${meta['.meta'].timing + 'ms'}).`, { color: 7 /* Colors.White */, effect: ansi_1.ColorEffect.Foreground, style: 3 /* FontStyles.Italic */ });
 }
 exports.dataflowCommand = {
     description: `Get mermaid code for the dataflow graph, start with '${retriever_1.fileProtocol}' to indicate a file`,
+    usesAnalyzer: true,
     usageExample: ':dataflow',
     aliases: ['d', 'df'],
     script: false,
-    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;
+    argsParser: (args) => (0, core_1.handleString)(args),
+    fn: async ({ output, analyzer }) => {
+        const result = await analyzer.dataflow();
+        const mermaid = (0, dfg_1.graphToMermaid)({ graph: result.graph, includeEnvironments: false }).string;
         output.stdout(mermaid);
         try {
             const clipboard = await Promise.resolve().then(() => __importStar(require('clipboardy')));
             clipboard.default.writeSync(mermaid);
-            output.stdout(formatInfo(output, 'mermaid code', result.dataflow['.meta'].timing));
+            output.stdout(formatInfo(output, 'mermaid code', result));
         }
         catch { /* do nothing this is a service thing */ }
     }
 };
 exports.dataflowStarCommand = {
     description: 'Returns the URL to mermaid.live',
+    usesAnalyzer: true,
     usageExample: ':dataflow*',
     aliases: ['d*', 'df*'],
     script: false,
-    fn: async ({ output, parser, remainingLine, config }) => {
-        const result = await replGetDataflow(config, parser, handleString(remainingLine));
-        const mermaid = (0, dfg_1.graphToMermaidUrl)(result.dataflow.graph, false);
+    argsParser: (args) => (0, core_1.handleString)(args),
+    fn: async ({ output, analyzer }) => {
+        const result = await analyzer.dataflow();
+        const mermaid = (0, dfg_1.graphToMermaidUrl)(result.graph, false);
         output.stdout(mermaid);
         try {
             const clipboard = await Promise.resolve().then(() => __importStar(require('clipboardy')));
             clipboard.default.writeSync(mermaid);
-            output.stdout(formatInfo(output, 'mermaid url', result.dataflow['.meta'].timing));
+            output.stdout(formatInfo(output, 'mermaid url', result));
         }
         catch { /* do nothing this is a service thing */ }
     }
 };
 exports.dataflowSimplifiedCommand = {
     description: `Get mermaid code for the simplified dataflow graph, start with '${retriever_1.fileProtocol}' to indicate a file`,
+    usesAnalyzer: true,
     usageExample: ':dataflowsimple',
     aliases: ['ds', 'dfs'],
     script: false,
-    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;
+    argsParser: (args) => (0, core_1.handleString)(args),
+    fn: async ({ output, analyzer }) => {
+        const result = await analyzer.dataflow();
+        const mermaid = (0, dfg_1.graphToMermaid)({ graph: result.graph, includeEnvironments: false, simplified: true }).string;
         output.stdout(mermaid);
         try {
             const clipboard = await Promise.resolve().then(() => __importStar(require('clipboardy')));
             clipboard.default.writeSync(mermaid);
-            output.stdout(formatInfo(output, 'mermaid code', result.dataflow['.meta'].timing));
+            output.stdout(formatInfo(output, 'mermaid code', result));
         }
         catch { /* do nothing this is a service thing */ }
     }
 };
 exports.dataflowSimpleStarCommand = {
     description: 'Returns the URL to mermaid.live',
+    usesAnalyzer: true,
     usageExample: ':dataflowsimple*',
     aliases: ['ds*', 'dfs*'],
     script: false,
-    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);
+    argsParser: (args) => (0, core_1.handleString)(args),
+    fn: async ({ output, analyzer }) => {
+        const result = await analyzer.dataflow();
+        const mermaid = (0, dfg_1.graphToMermaidUrl)(result.graph, false, undefined, true);
         output.stdout(mermaid);
         try {
             const clipboard = await Promise.resolve().then(() => __importStar(require('clipboardy')));
             clipboard.default.writeSync(mermaid);
-            output.stdout(formatInfo(output, 'mermaid url', result.dataflow['.meta'].timing));
+            output.stdout(formatInfo(output, 'mermaid url', result));
         }
         catch { /* do nothing this is a service thing */ }
     }

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

@@ -30,6 +30,7 @@ async function executeRShellCommand(output, shell, statement) {
 }
 exports.executeCommand = {
     description: 'Execute the given code as R code (essentially similar to using now command). This requires the `--r-session-access` flag to be set and requires the r-shell engine.',
+    usesAnalyzer: false,
     usageExample: ':execute',
     aliases: ['e', 'r'],
     script: false,

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

@@ -53,6 +53,7 @@ function getLineage(criterion, graph, idMap) {
 }
 exports.lineageCommand = {
     description: 'Get the lineage of an R object',
+    usesAnalyzer: false,
     usageExample: ':lineage',
     aliases: ['lin'],
     script: false,

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

@@ -1,6 +1,7 @@
 import type { OutputFormatter } from '../../../util/text/ansi';
 import type { KnownParser } from '../../../r-bridge/parser';
 import type { FlowrConfigOptions } from '../../../config';
+import type { FlowrAnalysisProvider } from '../../../project/flowr-analyzer';
 /**
  * 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).
@@ -20,20 +21,29 @@ export interface ReplOutput {
  */
 export declare const standardReplOutput: ReplOutput;
 /**
- * Information passed to each repl command function
+ * Information passed to each {@link ReplCommand#fn}.
  */
 export interface ReplCommandInformation {
     output: ReplOutput;
+    allowRSessionAccess: boolean;
     parser: KnownParser;
     remainingLine: string;
-    allowRSessionAccess: boolean;
     config: FlowrConfigOptions;
 }
+/**
+ * Information passed to each {@link ReplCodeCommand#fn}.
+ * The {@link analyzer} has the {@link RParseRequest}.
+ */
+export interface ReplCodeCommandInformation {
+    output: ReplOutput;
+    analyzer: FlowrAnalysisProvider;
+    remainingArgs: string[];
+}
 /**
  * Content of a single command in the repl.
  * The command may execute an external script or simply call *flowR* functions.
  */
-export interface ReplCommand {
+export interface ReplBaseCommand {
     /** Aliases of the command (without the leading colon), every alias must be unique (this is checked at runtime) */
     aliases: string[];
     /** A human-readable description of what the command does */
@@ -42,9 +52,30 @@ export interface ReplCommand {
     script: boolean;
     /** Example of how to use the command, for example `:slicer --help` */
     usageExample: string;
+}
+export interface ReplCommand extends ReplBaseCommand {
+    usesAnalyzer: false;
     /**
      * 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: (info: ReplCommandInformation) => Promise<void> | void;
 }
+/**
+ * Repl command that uses the {@link FlowrAnalyzer}
+ */
+export interface ReplCodeCommand extends ReplBaseCommand {
+    usesAnalyzer: true;
+    /**
+     * 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: (info: ReplCodeCommandInformation) => Promise<void> | void;
+    /**
+     * Argument parser function which handles the input given after the repl command
+     */
+    argsParser: (remainingLine: string) => {
+        input: string;
+        remaining: string[];
+    };
+}

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

@@ -1,3 +1,3 @@
-import type { ReplCommand } from './repl-main';
-export declare const normalizeCommand: ReplCommand;
-export declare const normalizeStarCommand: ReplCommand;
+import type { ReplCodeCommand } from './repl-main';
+export declare const normalizeCommand: ReplCodeCommand;
+export declare const normalizeStarCommand: ReplCodeCommand;

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

@@ -34,51 +34,47 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeStarCommand = exports.normalizeCommand = void 0;
-const default_pipelines_1 = require("../../../core/steps/pipeline/default-pipelines");
 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, config) {
-    return await (0, default_pipelines_1.createNormalizePipeline)(parser, {
-        request: (0, retriever_1.requestFromInput)(remainingLine.trim())
-    }, config).allRemainingSteps();
-}
-function handleString(code) {
-    return code.startsWith('"') ? JSON.parse(code) : code;
-}
-function formatInfo(out, type, timing) {
-    return out.formatter.format(`Copied ${type} to clipboard (normalize: ${timing}ms).`, { color: 7 /* Colors.White */, effect: ansi_1.ColorEffect.Foreground, style: 3 /* FontStyles.Italic */ });
+const core_1 = require("../core");
+function formatInfo(out, type, meta) {
+    return out.formatter.format(`Copied ${type} to clipboard (normalize: ${meta['.meta'].timing + 'ms'}).`, { color: 7 /* Colors.White */, effect: ansi_1.ColorEffect.Foreground, style: 3 /* FontStyles.Italic */ });
 }
 exports.normalizeCommand = {
     description: `Get mermaid code for the normalized AST of R code, start with '${retriever_1.fileProtocol}' to indicate a file`,
+    usesAnalyzer: true,
     usageExample: ':normalize',
     aliases: ['n'],
     script: false,
-    fn: async ({ output, parser, remainingLine, config }) => {
-        const result = await normalize(parser, handleString(remainingLine), config);
-        const mermaid = (0, ast_1.normalizedAstToMermaid)(result.normalize.ast);
+    argsParser: (args) => (0, core_1.handleString)(args),
+    fn: async ({ output, analyzer }) => {
+        const result = await analyzer.normalize();
+        const mermaid = (0, ast_1.normalizedAstToMermaid)(result.ast);
         output.stdout(mermaid);
         try {
             const clipboard = await Promise.resolve().then(() => __importStar(require('clipboardy')));
             clipboard.default.writeSync(mermaid);
-            output.stdout(formatInfo(output, 'mermaid url', result.normalize['.meta'].timing));
+            output.stdout(formatInfo(output, 'mermaid url', result));
         }
         catch { /* do nothing this is a service thing */ }
     }
 };
 exports.normalizeStarCommand = {
     description: 'Returns the URL to mermaid.live',
+    usesAnalyzer: true,
     usageExample: ':normalize*',
     aliases: ['n*'],
     script: false,
-    fn: async ({ output, parser, remainingLine, config }) => {
-        const result = await normalize(parser, handleString(remainingLine), config);
-        const mermaid = (0, ast_1.normalizedAstToMermaidUrl)(result.normalize.ast);
+    argsParser: (args) => (0, core_1.handleString)(args),
+    fn: async ({ output, analyzer }) => {
+        const result = await analyzer.normalize();
+        const mermaid = (0, ast_1.normalizedAstToMermaidUrl)(result.ast);
         output.stdout(mermaid);
         try {
             const clipboard = await Promise.resolve().then(() => __importStar(require('clipboardy')));
             clipboard.default.writeSync(mermaid);
-            output.stdout(formatInfo(output, 'mermaid url', result.normalize['.meta'].timing));
+            output.stdout(formatInfo(output, 'mermaid url', result));
         }
         catch { /* do nothing this is a service thing */ }
     }

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

@@ -1,2 +1,2 @@
-import type { ReplCommand } from './repl-main';
-export declare const parseCommand: ReplCommand;
+import type { ReplCodeCommand } from './repl-main';
+export declare const parseCommand: ReplCodeCommand;

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

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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 default_pipelines_1 = require("../../../core/steps/pipeline/default-pipelines");
 const retriever_1 = require("../../../r-bridge/retriever");
 function toDepthMap(entry) {
     const visit = [{ depth: 0, node: entry }];
@@ -127,20 +126,26 @@ function depthListToTextTree(list, f) {
 }
 exports.parseCommand = {
     description: `Prints ASCII Art of the parsed, unmodified AST, start with '${retriever_1.fileProtocol}' to indicate a file`,
+    usesAnalyzer: true,
     usageExample: ':parse',
     aliases: ['p'],
     script: false,
-    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()))
-        }, config).allRemainingSteps();
-        if (parser.name === 'r-shell') {
-            const object = (0, format_1.convertPreparedParsedData)((0, format_1.prepareParsedData)(result.parse.parsed));
+    argsParser: (line) => {
+        return {
+            // Threat the whole input line as R code
+            input: (0, retriever_1.removeRQuotes)(line.trim()),
+            remaining: []
+        };
+    },
+    fn: async ({ output, analyzer }) => {
+        const result = await analyzer.parse();
+        if (analyzer.parserName() === 'r-shell') {
+            const object = (0, format_1.convertPreparedParsedData)((0, format_1.prepareParsedData)(result.parsed));
             output.stdout(depthListToTextTree(toDepthMap(object), output.formatter));
         }
         else {
             // print the tree-sitter ast
-            output.stdout(depthListToTextTree(treeSitterToDepthList(result.parse.parsed.rootNode), output.formatter));
+            output.stdout(depthListToTextTree(treeSitterToDepthList(result.parsed.rootNode), output.formatter));
         }
     }
 };

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

@@ -1,3 +1,3 @@
-import type { ReplCommand } from './repl-main';
-export declare const queryCommand: ReplCommand;
-export declare const queryStarCommand: ReplCommand;
+import type { ReplCodeCommand } from './repl-main';
+export declare const queryCommand: ReplCodeCommand;
+export declare const queryStarCommand: ReplCodeCommand;

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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.queryStarCommand = exports.queryCommand = void 0;
-const default_pipelines_1 = require("../../../core/steps/pipeline/default-pipelines");
 const retriever_1 = require("../../../r-bridge/retriever");
 const args_1 = require("../../../util/text/args");
 const ansi_1 = require("../../../util/text/ansi");
@@ -9,11 +8,6 @@ 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(config, parser, remainingLine) {
-    return await (0, default_pipelines_1.createDataflowPipeline)(parser, {
-        request: (0, retriever_1.requestFromInput)(remainingLine.trim())
-    }, config).allRemainingSteps();
-}
 function printHelp(output) {
     output.stderr(`Format: ${(0, ansi_1.italic)(':query "<query>" <code>', output.formatter)}`);
     output.stdout('The query is an array of query objects to represent multiple queries. Each query object may have the following properties:');
@@ -24,9 +18,8 @@ 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, config) {
-    const args = (0, args_1.splitAtEscapeSensitive)(line);
-    const query = args.shift();
+async function processQueryArgs(output, analyzer, remainingArgs) {
+    const query = remainingArgs.shift();
     if (!query) {
         output.stderr('No query provided, use \':query help\' to get more information.');
         return;
@@ -35,12 +28,12 @@ async function processQueryArgs(line, parser, output, config) {
         printHelp(output);
         return;
     }
-    let parsedQuery = [];
+    let parsedQuery;
     if (query.startsWith('@')) {
         const queryName = query.slice(1);
         const queryObj = query_1.SupportedQueries[queryName];
         if (queryObj?.fromLine) {
-            const q = queryObj.fromLine(args, config);
+            const q = queryObj.fromLine(remainingArgs, analyzer.flowrConfig);
             parsedQuery = q ? (Array.isArray(q) ? q : [q]) : [];
         }
         else {
@@ -65,34 +58,51 @@ async function processQueryArgs(line, parser, output, config) {
     else {
         parsedQuery = [{ type: 'call-context', callName: query }];
     }
-    const processed = await getDataflow(config, parser, args.join(' '));
     return {
+        query: await (0, query_1.executeQueries)({
+            analyzer,
+        }, parsedQuery),
         parsedQuery,
-        query: await Promise.resolve((0, query_1.executeQueries)({ dataflow: processed.dataflow, ast: processed.normalize, config }, parsedQuery)),
-        processed
+        analyzer
+    };
+}
+/**
+ * Function for splitting the input line.
+ * The first token is the query command.
+ * The rest of the line is treated as input code.
+ */
+function parseArgs(line) {
+    const args = (0, args_1.splitAtEscapeSensitive)(line);
+    return {
+        input: args.join(' ').trim(),
+        remaining: args
     };
 }
 exports.queryCommand = {
     description: `Query the given R code, start with '${retriever_1.fileProtocol}' to indicate a file. The query is to be a valid query in json format (use 'help' to get more information).`,
+    usesAnalyzer: true,
     usageExample: ':query "<query>" <code>',
     aliases: [],
     script: false,
-    fn: async ({ output, parser, remainingLine, config }) => {
+    argsParser: parseArgs,
+    fn: async ({ output, analyzer, remainingArgs }) => {
         const totalStart = Date.now();
-        const results = await processQueryArgs(remainingLine, parser, output, config);
+        const results = await processQueryArgs(output, analyzer, remainingArgs);
         const totalEnd = Date.now();
         if (results) {
-            output.stdout((0, query_print_1.asciiSummaryOfQueryResult)(ansi_1.ansiFormatter, totalEnd - totalStart, results.query, results.processed, results.parsedQuery));
+            output.stdout(await (0, query_print_1.asciiSummaryOfQueryResult)(ansi_1.ansiFormatter, totalEnd - totalStart, results.query, results.analyzer, results.parsedQuery));
         }
     }
 };
 exports.queryStarCommand = {
     description: 'Similar to query, but returns the output in json format.',
+    usesAnalyzer: true,
     usageExample: ':query* <query> <code>',
     aliases: [],
     script: false,
-    fn: async ({ output, parser, remainingLine, config }) => {
-        const results = await processQueryArgs(remainingLine, parser, output, config);
+    argsParser: parseArgs,
+    fn: async ({ output, analyzer, remainingArgs }) => {
+        const results = await processQueryArgs(output, analyzer, remainingArgs);
         if (results) {
             output.stdout(JSON.stringify(results.query, json_1.jsonReplacer));
         }

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

@@ -4,6 +4,7 @@ exports.quitCommand = void 0;
 const log_1 = require("../../../util/log");
 exports.quitCommand = {
     description: 'End the repl',
+    usesAnalyzer: false,
     aliases: ['q', 'exit'],
     usageExample: ':quit',
     script: false,

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

@@ -21,6 +21,7 @@ async function printVersionInformation(output, parser) {
 }
 exports.versionCommand = {
     description: 'Prints the version of flowR as well as the current version of R',
+    usesAnalyzer: false,
     aliases: [],
     usageExample: ':version',
     script: false,

package/cli/repl/core.d.ts

@@ -8,6 +8,10 @@ import type { FlowrConfigOptions } from '../../config';
  */
 export declare function replCompleter(line: string, config: FlowrConfigOptions): [string[], string];
 export declare function makeDefaultReplReadline(config: FlowrConfigOptions): readline.ReadLineOptions;
+export declare function handleString(code: string): {
+    input: string;
+    remaining: never[];
+};
 /**
  * This function interprets the given `expr` as a REPL command (see {@link repl} for more on the semantics).
  *
@@ -27,7 +31,6 @@ export interface FlowrReplOptions extends MergeableRecord {
     /**
      * 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}.
-    * For the default arguments, see {@link DEFAULT_REPL_READLINE_CONFIGURATION}.
      */
     readonly rl?: readline.Interface;
     /** Defines two methods that every function in the repl uses to output its data. */

package/cli/repl/core.js

@@ -38,6 +38,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.replCompleter = replCompleter;
 exports.makeDefaultReplReadline = makeDefaultReplReadline;
+exports.handleString = handleString;
 exports.replProcessAnswer = replProcessAnswer;
 exports.repl = repl;
 exports.loadReplHistory = loadReplHistory;
@@ -61,6 +62,7 @@ const shell_1 = require("../../r-bridge/shell");
 const log_1 = require("../../util/log");
 const config_1 = require("../../config");
 const query_1 = require("../../queries/query");
+const flowr_analyzer_builder_1 = require("../../project/flowr-analyzer-builder");
 let _replCompleterKeywords = undefined;
 function replCompleterKeywords() {
     if (_replCompleterKeywords === undefined) {
@@ -129,6 +131,12 @@ function makeDefaultReplReadline(config) {
         completer: (c) => replCompleter(c, config)
     };
 }
+function handleString(code) {
+    return {
+        input: code.startsWith('"') ? JSON.parse(code) : code,
+        remaining: []
+    };
+}
 async function replProcessStatement(output, statement, parser, allowRSessionAccess, config) {
     if (statement.startsWith(':')) {
         const command = statement.slice(1).split(' ')[0].toLowerCase();
@@ -136,7 +144,19 @@ async function replProcessStatement(output, statement, parser, allowRSessionAcce
         const bold = (s) => output.formatter.format(s, { style: 1 /* FontStyles.Bold */ });
         if (processor) {
             try {
-                await processor.fn({ output, parser, remainingLine: statement.slice(command.length + 2).trim(), allowRSessionAccess, config });
+                const remainingLine = statement.slice(command.length + 2).trim();
+                if (processor.usesAnalyzer) {
+                    const args = processor.argsParser(remainingLine);
+                    const request = (0, retriever_1.requestFromInput)(args.input);
+                    const analyzer = await new flowr_analyzer_builder_1.FlowrAnalyzerBuilder(request)
+                        .setConfig(config)
+                        .setParser(parser)
+                        .build();
+                    await processor.fn({ output, analyzer, remainingArgs: args.remaining });
+                }
+                else {
+                    await processor.fn({ output, parser, remainingLine, 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`);

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

@@ -1,9 +1,13 @@
 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 { PipelineOutput } from '../../../core/steps/pipeline/pipeline';
 import type { DeepPartial } from 'ts-essentials';
-import type { KnownParser } from '../../../r-bridge/parser';
+import type { KnownParser, ParseStepOutput } from '../../../r-bridge/parser';
 import type { FlowrConfigOptions } from '../../../config';
+import type { NormalizedAst } from '../../../r-bridge/lang-4.x/ast/model/processing/decorate';
+import type { DataflowInformation } from '../../../dataflow/info';
+import type { Tree } from 'web-tree-sitter';
 /**
  * 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.
@@ -21,10 +25,10 @@ export declare class FlowRServerConnection {
     private handleData;
     private handleFileAnalysisRequest;
     private sendFileAnalysisResponse;
-    private createPipelineExecutorForRequest;
+    private createAnalyzerForRequest;
     private handleSliceRequest;
     private handleRepl;
     private handleLineageRequest;
     private handleQueryRequest;
 }
-export declare function sanitizeAnalysisResults(results: Partial<PipelineOutput<typeof DEFAULT_SLICING_PIPELINE>>): DeepPartial<PipelineOutput<typeof DEFAULT_SLICING_PIPELINE>>;
+export declare function sanitizeAnalysisResults(parse: ParseStepOutput<string | Tree>, normalize: NormalizedAst, dataflow: DataflowInformation): DeepPartial<PipelineOutput<typeof DEFAULT_SLICING_PIPELINE | typeof TREE_SITTER_DATAFLOW_PIPELINE>>;