@eagleoutice/flowr 2.6.0 → 2.6.2

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

@@ -1,13 +1,10 @@
-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';
+import { type OutputFormatter } from '../../../util/text/ansi';
+import type { FlowrAnalysisProvider, ReadonlyFlowrAnalysisProvider } 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).
  *
  * The formatter allows to dynamically change the use of ansi escape sequences (see {@link OutputFormatter})
- *
  * @see standardReplOutput
  */
 export interface ReplOutput {
@@ -26,9 +23,8 @@ export declare const standardReplOutput: ReplOutput;
 export interface ReplCommandInformation {
     output: ReplOutput;
     allowRSessionAccess: boolean;
-    parser: KnownParser;
+    analyzer: ReadonlyFlowrAnalysisProvider;
     remainingLine: string;
-    config: FlowrConfigOptions;
 }
 /**
  * Information passed to each {@link ReplCodeCommand#fn}.
@@ -54,28 +50,35 @@ export interface ReplBaseCommand {
     usageExample: string;
 }
 export interface ReplCommand extends ReplBaseCommand {
-    usesAnalyzer: false;
+    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;
 }
+/**
+ * Result of parsing a REPL code command line.
+ * `rCode` may be undefined, in which case the R code of a previous REPL command will be re-used.
+ */
+interface ParsedReplLine {
+    rCode: string | undefined;
+    remaining: string[];
+}
 /**
  * Repl command that uses the {@link FlowrAnalyzer}
  */
 export interface ReplCodeCommand extends ReplBaseCommand {
-    usesAnalyzer: true;
+    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
+     * Argument parser function which handles the input given after the repl command.
+     * If no R code is returned, the input R code of a previous REPL command will be re-used for processing the current REPL command.
      */
-    argsParser: (remainingLine: string) => {
-        input: string;
-        remaining: string[];
-    };
+    argsParser: (remainingLine: string) => ParsedReplLine;
 }
+export {};

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

@@ -43,7 +43,7 @@ function formatInfo(out, type, meta) {
 }
 exports.normalizeCommand = {
     description: `Get mermaid code for the normalized AST of R code, start with '${retriever_1.fileProtocol}' to indicate a file`,
-    usesAnalyzer: true,
+    isCodeCommand: true,
     usageExample: ':normalize',
     aliases: ['n'],
     script: false,
@@ -62,7 +62,7 @@ exports.normalizeCommand = {
 };
 exports.normalizeStarCommand = {
     description: 'Returns the URL to mermaid.live',
-    usesAnalyzer: true,
+    isCodeCommand: true,
     usageExample: ':normalize*',
     aliases: ['n*'],
     script: false,

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

@@ -126,20 +126,21 @@ 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,
+    isCodeCommand: true,
     usageExample: ':parse',
     aliases: ['p'],
     script: false,
     argsParser: (line) => {
         return {
             // Threat the whole input line as R code
-            input: (0, retriever_1.removeRQuotes)(line.trim()),
+            rCode: (0, retriever_1.removeRQuotes)(line.trim()),
             remaining: []
         };
     },
     fn: async ({ output, analyzer }) => {
         const result = await analyzer.parse();
-        if (analyzer.parserName() === 'r-shell') {
+        const parserInfo = analyzer.parserInformation();
+        if (parserInfo.name === 'r-shell') {
             const object = (0, format_1.convertPreparedParsedData)((0, format_1.prepareParsedData)(result.parsed));
             output.stdout(depthListToTextTree(toDepthMap(object), output.formatter));
         }

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

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

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

@@ -4,7 +4,7 @@ exports.quitCommand = void 0;
 const log_1 = require("../../../util/log");
 exports.quitCommand = {
     description: 'End the repl',
-    usesAnalyzer: false,
+    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,30 +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',
-    usesAnalyzer: false,
+    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,36 +1,54 @@
 import * as readline from 'readline';
-import type { ReplOutput } from './commands/repl-main';
+import { type ReplOutput } from './commands/repl-main';
 import type { MergeableRecord } from '../../util/objects';
-import type { KnownParser } from '../../r-bridge/parser';
 import type { FlowrConfigOptions } from '../../config';
+import type { FlowrAnalyzer } from '../../project/flowr-analyzer';
+/**
+ * Completion suggestions for a specific REPL command
+ */
+export interface CommandCompletions {
+    /** The possible completions for the current argument */
+    readonly completions: string[];
+    /**
+     * The current argument fragment being completed, if any.
+     * This is relevant if an argument is composed of multiple parts (e.g. comma-separated lists).
+     */
+    readonly argumentPart?: string;
+}
 /**
  * Used by the repl to provide automatic completions for a given (partial) input line
  */
 export declare function replCompleter(line: string, config: FlowrConfigOptions): [string[], string];
+/**
+ * Produces default readline options for the flowR REPL
+ */
 export declare function makeDefaultReplReadline(config: FlowrConfigOptions): readline.ReadLineOptions;
+/**
+ * Handles a string input for the REPL, returning the parsed string and any remaining input.
+ */
 export declare function handleString(code: string): {
-    input: string;
+    rCode: 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}.
+     * If you want to provide a custom one but use the same `completer`, refer to {@link replCompleter}.
      */
     readonly rl?: readline.Interface;
     /** Defines two methods that every function in the repl uses to output its data. */
@@ -46,12 +64,12 @@ export interface FlowrReplOptions extends MergeableRecord {
  * The repl allows for two kinds of inputs:
  * - Starting with a colon `:`, indicating a command (probe `:help`, and refer to {@link commands}) </li>
  * - Starting with anything else, indicating default R code to be directly executed. If you kill the underlying shell, that is on you! </li>
- *
  * @param options - The options for the repl. See {@link FlowrReplOptions} for more information.
- * @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>;
+/**
+ * Loads the REPL history from the given file.
+ */
 export declare function loadReplHistory(historyFile: string): string[] | undefined;

package/cli/repl/core.js

@@ -44,7 +44,6 @@ exports.repl = repl;
 exports.loadReplHistory = loadReplHistory;
 /**
  * Basically a helper file to allow the main 'flowr' script (located in the source root) to provide its repl
- *
  * @module
  */
 const prompt_1 = require("./prompt");
@@ -58,11 +57,9 @@ 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");
-const flowr_analyzer_builder_1 = require("../../project/flowr-analyzer-builder");
+const strings_1 = require("../../util/text/strings");
 let _replCompleterKeywords = undefined;
 function replCompleterKeywords() {
     if (_replCompleterKeywords === undefined) {
@@ -82,44 +79,50 @@ function replCompleter(line, config) {
     if (splitLine.length > 1 || startingNewArg) {
         const commandNameColon = replCompleterKeywords().find(k => splitLine[0] === k);
         if (commandNameColon) {
-            const completions = [];
+            let completions = [];
+            let currentArg = startingNewArg ? '' : splitLine[splitLine.length - 1];
             const commandName = commandNameColon.slice(1);
             const cmd = (0, repl_commands_1.getCommand)(commandName);
             if (cmd?.script === true) {
                 // autocomplete script arguments
                 const options = scripts_info_1.scripts[commandName].options;
-                completions.push(...(0, scripts_info_1.getValidOptionsForCompletion)(options, splitLine).map(o => `${o} `));
+                completions = completions.concat((0, scripts_info_1.getValidOptionsForCompletion)(options, splitLine).map(o => `${o} `));
             }
             else if (commandName.startsWith('query')) {
-                completions.push(...replQueryCompleter(splitLine, config));
+                const { completions: queryCompletions, argumentPart: splitArg } = replQueryCompleter(splitLine, startingNewArg, config);
+                if (splitArg !== undefined) {
+                    currentArg = splitArg;
+                }
+                completions = completions.concat(queryCompletions);
             }
             else {
                 // autocomplete command arguments (specifically, autocomplete the file:// protocol)
                 completions.push(retriever_1.fileProtocol);
             }
-            const currentArg = startingNewArg ? '' : splitLine[splitLine.length - 1];
             return [completions.filter(a => a.startsWith(currentArg)), currentArg];
         }
     }
     // if no command is already typed, just return all commands that match
     return [replCompleterKeywords().filter(k => k.startsWith(line)).map(k => `${k} `), line];
 }
-function replQueryCompleter(splitLine, config) {
+function replQueryCompleter(splitLine, startingNewArg, config) {
     const nonEmpty = splitLine.slice(1).map(s => s.trim()).filter(s => s.length > 0);
     const queryShorts = Object.keys(query_1.SupportedQueries).map(q => `@${q}`).concat(['help']);
-    let candidates = [];
-    if (nonEmpty.length == 0 || (nonEmpty.length == 1 && queryShorts.some(q => q.startsWith(nonEmpty[0]) && nonEmpty[0] !== q))) {
-        candidates = candidates.concat(queryShorts.map(q => `${q} `));
+    if (nonEmpty.length == 0 || (nonEmpty.length == 1 && queryShorts.some(q => q.startsWith(nonEmpty[0]) && nonEmpty[0] !== q && !startingNewArg))) {
+        return { completions: queryShorts.map(q => `${q} `) };
     }
     else {
         const q = nonEmpty[0].slice(1);
         const queryElement = query_1.SupportedQueries[q];
         if (queryElement?.completer) {
-            candidates = candidates.concat(queryElement.completer(nonEmpty.slice(1), config));
+            return queryElement.completer(nonEmpty.slice(1), startingNewArg, config);
         }
     }
-    return candidates;
+    return { completions: [] };
 }
+/**
+ * Produces default readline options for the flowR REPL
+ */
 function makeDefaultReplReadline(config) {
     return {
         input: process.stdin,
@@ -131,13 +134,16 @@ function makeDefaultReplReadline(config) {
         completer: (c) => replCompleter(c, config)
     };
 }
+/**
+ * Handles a string input for the REPL, returning the parsed string and any remaining input.
+ */
 function handleString(code) {
     return {
-        input: code.startsWith('"') ? JSON.parse(code) : code,
+        rCode: code.length == 0 ? undefined : (0, strings_1.startAndEndsWith)(code, '"') ? JSON.parse(code) : code,
         remaining: []
     };
 }
-async function replProcessStatement(output, statement, parser, allowRSessionAccess, config) {
+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);
@@ -145,17 +151,16 @@ async function replProcessStatement(output, statement, parser, allowRSessionAcce
         if (processor) {
             try {
                 const remainingLine = statement.slice(command.length + 2).trim();
-                if (processor.usesAnalyzer) {
+                if (processor.isCodeCommand) {
                     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();
+                    if (args.rCode) {
+                        analyzer.reset();
+                        analyzer.addRequest((0, retriever_1.requestFromInput)(args.rCode));
+                    }
                     await processor.fn({ output, analyzer, remainingArgs: args.remaining });
                 }
                 else {
-                    await processor.fn({ output, parser, remainingLine, allowRSessionAccess, config });
+                    await processor.fn({ output, analyzer, remainingLine, allowRSessionAccess });
                 }
             }
             catch (e) {
@@ -170,22 +175,20 @@ 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) {
-    const statements = (0, args_1.splitAtEscapeSensitive)(expr, false, ';');
+async function replProcessAnswer(analyzer, output, expr, allowRSessionAccess) {
+    const statements = (0, args_1.splitAtEscapeSensitive)(expr, false, /^;\s*:/);
     for (const statement of statements) {
-        await replProcessStatement(output, statement, parser, allowRSessionAccess, config);
+        await replProcessStatement(output, statement.trim(), analyzer, allowRSessionAccess);
     }
 }
 /**
@@ -194,14 +197,11 @@ async function replProcessAnswer(config, output, expr, parser, allowRSessionAcce
  * The repl allows for two kinds of inputs:
  * - Starting with a colon `:`, indicating a command (probe `:help`, and refer to {@link commands}) </li>
  * - Starting with anything else, indicating default R code to be directly executed. If you kill the underlying shell, that is on you! </li>
- *
  * @param options - The options for the repl. See {@link FlowrReplOptions} for more information.
- * @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' }));
     }
@@ -210,7 +210,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);
@@ -218,6 +218,9 @@ async function repl(config, { parser = new shell_1.RShell((0, config_1.getEngine
         });
     }
 }
+/**
+ * Loads the REPL history from the given file.
+ */
 function loadReplHistory(historyFile) {
     try {
         if (!fs_1.default.existsSync(historyFile)) {

package/cli/repl/execute.d.ts

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

package/cli/repl/execute.js

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

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

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

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

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

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

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

package/cli/repl/print-version.js

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