@eagleoutice/flowr 2.5.0 → 2.6.1

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

@@ -3,22 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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, allowRSessionAccess, remainingLine }) {
+async function tryExecuteRShellCommand({ output, analyzer, allowRSessionAccess, remainingLine }) {
+    const parserInfo = await analyzer.parserInformation();
     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. When running flowR with npm, you have to use an extra ${output.formatter.format('--', { style: 1 /* FontStyles.Bold */ })} to separate flowR from npm arguments.`);
+If you want to do so, please restart flowR with the ${output.formatter.format('--r-session-access', { style: 1 /* FontStyles.Bold */ })} flag${parserInfo.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, remainingLine);
+    else if (parserInfo.name === 'r-shell') {
+        await executeRShellCommand(output, analyzer, 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. 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) {
+async function executeRShellCommand(output, analyzer, statement) {
     try {
-        const result = await shell.sendCommandWithOutput(statement, {
+        const result = await analyzer.sendCommandWithOutput(statement, {
             from: 'both',
             automaticallyTrimOutput: true
         });
@@ -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.',
+    isCodeCommand: false,
     usageExample: ':execute',
     aliases: ['e', 'r'],
     script: false,

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

@@ -1,4 +1,4 @@
-import type { ReplCommand } from './repl-main';
+import type { ReplCodeCommand } from './repl-main';
 import type { SingleSlicingCriterion } from '../../../slicing/criterion/parse';
 import type { NodeId } from '../../../r-bridge/lang-4.x/ast/model/processing/node-id';
 import type { DataflowGraph } from '../../../dataflow/graph/graph';
@@ -12,4 +12,4 @@ import type { AstIdMap } from '../../../r-bridge/lang-4.x/ast/model/processing/d
  * @returns The lineage of the node represented as a set of node ids
  */
 export declare function getLineage(criterion: SingleSlicingCriterion, graph: DataflowGraph, idMap?: AstIdMap): Set<NodeId>;
-export declare const lineageCommand: ReplCommand;
+export declare const lineageCommand: ReplCodeCommand;

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

@@ -2,19 +2,12 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.lineageCommand = void 0;
 exports.getLineage = getLineage;
-const default_pipelines_1 = require("../../../core/steps/pipeline/default-pipelines");
-const retriever_1 = require("../../../r-bridge/retriever");
 const parse_1 = require("../../../slicing/criterion/parse");
 const edge_1 = require("../../../dataflow/graph/edge");
 const assert_1 = require("../../../util/assert");
 function splitAt(str, idx) {
     return [str.slice(0, idx), str.slice(idx)];
 }
-async function getDfg(config, parser, remainingLine) {
-    return await (0, default_pipelines_1.createDataflowPipeline)(parser, {
-        request: (0, retriever_1.requestFromInput)(remainingLine.trim())
-    }, 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);
 }
@@ -53,13 +46,20 @@ function getLineage(criterion, graph, idMap) {
 }
 exports.lineageCommand = {
     description: 'Get the lineage of an R object',
+    isCodeCommand: true,
     usageExample: ':lineage',
     aliases: ['lin'],
     script: false,
-    fn: async ({ output, parser, remainingLine, config }) => {
-        const [criterion, rest] = splitAt(remainingLine, remainingLine.indexOf(' '));
-        const { dataflow: dfg } = await getDfg(config, parser, rest);
-        const lineageIds = getLineage(criterion, dfg.graph);
+    argsParser: (args) => {
+        const [criterion, rest] = splitAt(args, args.indexOf(' '));
+        const code = rest.trim();
+        return {
+            input: code.startsWith('"') ? JSON.parse(code) : code,
+            remaining: [criterion]
+        };
+    },
+    fn: async ({ output, analyzer, remainingArgs }) => {
+        const lineageIds = getLineage(remainingArgs[0], (await analyzer.dataflow()).graph);
         output.stdout([...lineageIds].join('\n'));
     }
 };

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

@@ -1,6 +1,5 @@
 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 +19,28 @@ 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;
-    parser: KnownParser;
-    remainingLine: string;
     allowRSessionAccess: boolean;
-    config: FlowrConfigOptions;
+    analyzer: FlowrAnalysisProvider;
+    remainingLine: string;
+}
+/**
+ * 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 +49,30 @@ export interface ReplCommand {
     script: boolean;
     /** Example of how to use the command, for example `:slicer --help` */
     usageExample: string;
+}
+export interface ReplCommand extends ReplBaseCommand {
+    isCodeCommand: 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 {
+    isCodeCommand: 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 | undefined;
+        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`,
+    isCodeCommand: 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',
+    isCodeCommand: 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,27 @@ function depthListToTextTree(list, f) {
 }
 exports.parseCommand = {
     description: `Prints ASCII Art of the parsed, unmodified AST, start with '${retriever_1.fileProtocol}' to indicate a file`,
+    isCodeCommand: 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();
+        const parserInfo = await 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));
         }
         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[1].trim() === 'help' ? '' : args.slice(1).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).`,
+    isCodeCommand: 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.',
+    isCodeCommand: 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',
+    isCodeCommand: false,
     aliases: ['q', 'exit'],
     usageExample: ':quit',
     script: false,

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

@@ -1,17 +1,2 @@
-import type { ReplCommand, ReplOutput } from './repl-main';
-import type { KnownParser } from '../../../r-bridge/parser';
-type Version = `${number}.${number}.${number}`;
-/**
- * Describes the version of flowR and the used R interpreter.
- */
-export interface VersionInformation {
-    /** The version of flowR */
-    flowr: Version;
-    /** The version of R identified by the underlying {@link RShell} */
-    r: Version | 'unknown' | 'none';
-    engine: string;
-}
-export declare function retrieveVersionInformation(parser: KnownParser): Promise<VersionInformation>;
-export declare function printVersionInformation(output: ReplOutput, parser: KnownParser): Promise<void>;
+import type { ReplCommand } from './repl-main';
 export declare const versionCommand: ReplCommand;
-export {};

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

@@ -1,29 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.versionCommand = void 0;
-exports.retrieveVersionInformation = retrieveVersionInformation;
-exports.printVersionInformation = printVersionInformation;
 const version_1 = require("../../../util/version");
-const assert_1 = require("../../../util/assert");
-const versionRegex = /^\d+\.\d+\.\d+/m;
-async function retrieveVersionInformation(parser) {
-    const flowr = (0, version_1.flowrVersion)().toString();
-    const r = await parser.rVersion();
-    (0, assert_1.guard)(versionRegex.test(flowr), `flowR version ${flowr} does not match the expected format!`);
-    (0, assert_1.guard)(r === 'unknown' || r === 'none' || versionRegex.test(r), `R version ${r} does not match the expected format!`);
-    return { flowr: flowr, r: r, engine: parser.name };
-}
-async function printVersionInformation(output, parser) {
-    const { flowr, r, engine } = await retrieveVersionInformation(parser);
-    output.stdout(`Engine: ${engine}`);
-    output.stdout(` flowR: ${flowr}`);
-    output.stdout(` R: ${r}`);
-}
 exports.versionCommand = {
     description: 'Prints the version of flowR as well as the current version of R',
+    isCodeCommand: false,
     aliases: [],
     usageExample: ':version',
     script: false,
-    fn: ({ output, parser }) => printVersionInformation(output, parser)
+    fn: ({ output, analyzer }) => (0, version_1.printVersionInformation)(output, analyzer)
 };
 //# sourceMappingURL=repl-version.js.map

package/cli/repl/core.d.ts

@@ -1,33 +1,37 @@
 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';
+import type { FlowrAnalyzer } from '../../project/flowr-analyzer';
 /**
  * Used by the repl to provide automatic completions for a given (partial) input line
  */
 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 | undefined;
+    remaining: never[];
+};
 /**
  * This function interprets the given `expr` as a REPL command (see {@link repl} for more on the semantics).
  *
- * @param config              - flowr Config
+ * @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 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(config: FlowrConfigOptions, output: ReplOutput, expr: string, parser: KnownParser, allowRSessionAccess: boolean): Promise<void>;
+export declare function replProcessAnswer(analyzer: FlowrAnalyzer, output: ReplOutput, expr: string, allowRSessionAccess: boolean): Promise<void>;
 /**
  * Options for the {@link repl} function.
  */
 export interface FlowrReplOptions extends MergeableRecord {
-    /** The shell to use, if you do not pass one it will automatically create a new one with the `revive` option set to 'always'. */
-    readonly parser?: KnownParser;
+    /**
+     * The flowR analyzer to use.
+     */
+    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}.
-    * 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. */
@@ -45,10 +49,9 @@ 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(config: FlowrConfigOptions, { parser, rl, output, historyFile, allowRSessionAccess }: FlowrReplOptions): Promise<void>;
+export declare function repl({ analyzer, rl, output, historyFile, allowRSessionAccess }: FlowrReplOptions): Promise<void>;
 export declare function loadReplHistory(historyFile: string): string[] | undefined;

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;
@@ -57,9 +58,7 @@ const repl_commands_1 = require("./commands/repl-commands");
 const scripts_info_1 = require("../common/scripts-info");
 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");
 const query_1 = require("../../queries/query");
 let _replCompleterKeywords = undefined;
 function replCompleterKeywords() {
@@ -129,14 +128,31 @@ function makeDefaultReplReadline(config) {
         completer: (c) => replCompleter(c, config)
     };
 }
-async function replProcessStatement(output, statement, parser, allowRSessionAccess, config) {
+function handleString(code) {
+    return {
+        input: code.length == 0 ? undefined : code.startsWith('"') ? JSON.parse(code) : code,
+        remaining: []
+    };
+}
+async function replProcessStatement(output, statement, analyzer, allowRSessionAccess) {
     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, remainingLine: statement.slice(command.length + 2).trim(), allowRSessionAccess, config });
+                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 processor.fn({ output, analyzer, remainingArgs: args.remaining });
+                }
+                else {
+                    await processor.fn({ output, analyzer, remainingLine, allowRSessionAccess });
+                }
             }
             catch (e) {
                 output.stdout(`${bold(`Failed to execute command ${command}`)}: ${e?.message}. Using the ${bold('--verbose')} flag on startup may provide additional information.\n`);
@@ -150,22 +166,21 @@ async function replProcessStatement(output, statement, parser, allowRSessionAcce
         }
     }
     else {
-        await (0, repl_execute_1.tryExecuteRShellCommand)({ output, parser, remainingLine: statement, allowRSessionAccess, config });
+        await (0, repl_execute_1.tryExecuteRShellCommand)({ output, analyzer, remainingLine: statement, allowRSessionAccess });
     }
 }
 /**
  * This function interprets the given `expr` as a REPL command (see {@link repl} for more on the semantics).
  *
- * @param config              - flowr Config
+ * @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 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(config, output, expr, parser, allowRSessionAccess) {
+async function replProcessAnswer(analyzer, output, expr, allowRSessionAccess) {
     const statements = (0, args_1.splitAtEscapeSensitive)(expr, false, ';');
     for (const statement of statements) {
-        await replProcessStatement(output, statement, parser, allowRSessionAccess, config);
+        await replProcessStatement(output, statement, analyzer, allowRSessionAccess);
     }
 }
 /**
@@ -176,12 +191,11 @@ async function replProcessAnswer(config, output, expr, parser, allowRSessionAcce
  * - 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(config, { parser = new shell_1.RShell((0, config_1.getEngineConfig)(config, 'r-shell'), { revive: 2 /* RShellReviveOptions.Always */ }), rl = readline.createInterface(makeDefaultReplReadline(config)), output = repl_main_1.standardReplOutput, historyFile = defaultHistoryFile, allowRSessionAccess = false }) {
+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' }));
     }
@@ -190,7 +204,7 @@ async function repl(config, { parser = new shell_1.RShell((0, config_1.getEngine
         await new Promise((resolve, reject) => {
             rl.question((0, prompt_1.prompt)(), answer => {
                 rl.pause();
-                replProcessAnswer(config, output, answer, parser, allowRSessionAccess).then(() => {
+                replProcessAnswer(analyzer, output, answer, allowRSessionAccess).then(() => {
                     rl.resume();
                     resolve();
                 }).catch(reject);