@eagleoutice/flowr 1.5.2 → 2.0.0

package/cli/repl/commands/quit.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quitCommand = void 0;
+const log_1 = require("../../../util/log");
+exports.quitCommand = {
+    description: 'End the repl',
+    aliases: ['q', 'exit'],
+    usageExample: ':quit',
+    script: false,
+    fn: () => {
+        log_1.log.info('bye');
+        process.exit(0);
+    }
+};
+//# sourceMappingURL=quit.js.map

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

@@ -0,0 +1,16 @@
+import type { ReplCommand, ReplOutput } from './main';
+import type { RShell } from '../../../r-bridge/shell';
+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';
+}
+export declare function retrieveVersionInformation(shell: RShell): Promise<VersionInformation>;
+export declare function printVersionInformation(output: ReplOutput, shell: RShell): Promise<void>;
+export declare const versionCommand: ReplCommand;
+export {};

package/cli/repl/commands/version.js

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

package/cli/repl/core.d.ts

@@ -0,0 +1,36 @@
+/// <reference types="node" />
+import * as readline from 'readline';
+import type { ReplOutput } from './commands/main';
+import { RShell } from '../../r-bridge/shell';
+/**
+ * Used by the repl to provide automatic completions for a given (partial) input line
+ */
+export declare function replCompleter(line: string): [string[], string];
+export declare const DEFAULT_REPL_READLINE_CONFIGURATION: readline.ReadLineOptions;
+/**
+ * This function interprets the given `expr` as a REPL command (see {@link repl} for more on the semantics).
+ *
+ * @param output   - Defines two methods that every function in the repl uses to output its data.
+ * @param expr     - The expression to process.
+ * @param shell    - The {@link RShell} to use (see {@link repl}).
+ */
+export declare function replProcessAnswer(output: ReplOutput, expr: string, shell: RShell): Promise<void>;
+/**
+ * Provides a never-ending repl (read-evaluate-print loop) processor that can be used to interact with a {@link RShell} as well as all flowR scripts.
+ *
+ * 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 shell     - The shell to use, if you do not pass one it will automatically create a new one with the `revive` option set to 'always'
+ * @param rl        - 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}.
+ * @param output    - Defines two methods that every function in the repl uses to output its data.
+ * @param historyFile - The file to use for persisting the repl's history. Passing undefined causes history not to be saved.
+ *
+ * For the execution, this function makes use of {@link replProcessAnswer}
+ *
+ */
+export declare function repl(shell?: RShell, rl?: readline.Interface, output?: ReplOutput, historyFile?: string | undefined): Promise<void>;
+export declare function loadReplHistory(historyFile: string): string[] | undefined;

package/cli/repl/core.js

@@ -0,0 +1,174 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadReplHistory = exports.repl = exports.replProcessAnswer = exports.DEFAULT_REPL_READLINE_CONFIGURATION = exports.replCompleter = void 0;
+/**
+ * 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");
+const readline = __importStar(require("readline"));
+const execute_1 = require("./commands/execute");
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const args_1 = require("../../util/args");
+const ansi_1 = require("../../util/ansi");
+const commands_1 = require("./commands/commands");
+const scripts_info_1 = require("../common/scripts-info");
+const retriever_1 = require("../../r-bridge/retriever");
+const main_1 = require("./commands/main");
+const shell_1 = require("../../r-bridge/shell");
+let _replCompleterKeywords = undefined;
+function replCompleterKeywords() {
+    if (_replCompleterKeywords === undefined) {
+        _replCompleterKeywords = Array.from((0, commands_1.getCommandNames)(), s => `:${s}`);
+    }
+    return _replCompleterKeywords;
+}
+const defaultHistoryFile = path_1.default.join(os_1.default.tmpdir(), '.flowrhistory');
+/**
+ * Used by the repl to provide automatic completions for a given (partial) input line
+ */
+function replCompleter(line) {
+    const splitLine = (0, args_1.splitAtEscapeSensitive)(line);
+    // did we just type a space (and are starting a new arg right now)?
+    const startingNewArg = line.endsWith(' ');
+    // if we typed a command fully already, autocomplete the arguments
+    if (splitLine.length > 1 || startingNewArg) {
+        const commandNameColon = replCompleterKeywords().find(k => splitLine[0] === k);
+        if (commandNameColon) {
+            const completions = [];
+            const commandName = commandNameColon.slice(1);
+            if ((0, commands_1.getCommand)(commandName)?.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} `));
+            }
+            else {
+                // autocomplete command arguments (specifically, autocomplete the file:// protocol)
+                completions.push(retriever_1.fileProtocol);
+            }
+            // add an empty option so that it doesn't autocomplete the only defined option immediately
+            completions.push(' ');
+            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];
+}
+exports.replCompleter = replCompleter;
+exports.DEFAULT_REPL_READLINE_CONFIGURATION = {
+    input: process.stdin,
+    output: process.stdout,
+    tabSize: 4,
+    terminal: true,
+    history: loadReplHistory(defaultHistoryFile),
+    removeHistoryDuplicates: true,
+    completer: replCompleter
+};
+async function replProcessStatement(output, statement, shell) {
+    if (statement.startsWith(':')) {
+        const command = statement.slice(1).split(' ')[0].toLowerCase();
+        const processor = (0, commands_1.getCommand)(command);
+        if (processor) {
+            try {
+                await processor.fn(output, shell, statement.slice(command.length + 2).trim());
+            }
+            catch (e) {
+                console.log(`${(0, ansi_1.bold)(`Failed to execute command ${command}`)}: ${e?.message}. Using the ${(0, ansi_1.bold)('--verbose')} flag on startup may provide additional information.`);
+            }
+        }
+        else {
+            console.log(`the command '${command}' is unknown, try ${(0, ansi_1.bold)(':help')} for more information`);
+        }
+    }
+    else {
+        await (0, execute_1.executeRShellCommand)(output, shell, statement);
+    }
+}
+/**
+ * This function interprets the given `expr` as a REPL command (see {@link repl} for more on the semantics).
+ *
+ * @param output   - Defines two methods that every function in the repl uses to output its data.
+ * @param expr     - The expression to process.
+ * @param shell    - The {@link RShell} to use (see {@link repl}).
+ */
+async function replProcessAnswer(output, expr, shell) {
+    const statements = (0, args_1.splitAtEscapeSensitive)(expr, false, ';');
+    for (const statement of statements) {
+        await replProcessStatement(output, statement, shell);
+    }
+}
+exports.replProcessAnswer = replProcessAnswer;
+/**
+ * Provides a never-ending repl (read-evaluate-print loop) processor that can be used to interact with a {@link RShell} as well as all flowR scripts.
+ *
+ * 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 shell     - The shell to use, if you do not pass one it will automatically create a new one with the `revive` option set to 'always'
+ * @param rl        - 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}.
+ * @param output    - Defines two methods that every function in the repl uses to output its data.
+ * @param historyFile - The file to use for persisting the repl's history. Passing undefined causes history not to be saved.
+ *
+ * For the execution, this function makes use of {@link replProcessAnswer}
+ *
+ */
+async function repl(shell = new shell_1.RShell({ revive: 2 /* RShellReviveOptions.Always */ }), rl = readline.createInterface(exports.DEFAULT_REPL_READLINE_CONFIGURATION), output = main_1.standardReplOutput, historyFile = defaultHistoryFile) {
+    if (historyFile) {
+        rl.on('history', h => fs_1.default.writeFileSync(historyFile, h.join('\n'), { encoding: 'utf-8' }));
+    }
+    // the incredible repl :D, we kill it with ':quit'
+    // eslint-disable-next-line no-constant-condition,@typescript-eslint/no-unnecessary-condition
+    while (true) {
+        await new Promise((resolve, reject) => {
+            rl.question((0, prompt_1.prompt)(), answer => {
+                rl.pause();
+                replProcessAnswer(output, answer, shell).then(() => {
+                    rl.resume();
+                    resolve();
+                }).catch(reject);
+            });
+        });
+    }
+}
+exports.repl = repl;
+function loadReplHistory(historyFile) {
+    if (!fs_1.default.existsSync(historyFile)) {
+        return undefined;
+    }
+    return fs_1.default.readFileSync(historyFile, { encoding: 'utf-8' }).split('\n');
+}
+exports.loadReplHistory = loadReplHistory;
+//# sourceMappingURL=core.js.map

package/cli/repl/execute.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+import type { Readable, Writable } from 'stream';
+type Stdio = [stdin: Writable | null, stdout: Readable | null, stderr: Readable | null, extra: Writable | Readable | null | undefined, extra: Writable | Readable | null | undefined];
+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.
+ */
+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.
+ * @param args        - The arguments you want to start your process with.
+ * @param io          - If you omit this argument, the in-, out- and error-channels of the script execution
+ *                      will be automatically forwarded to the respective in-, out- and error-channels of your process.
+ *                      However, by defining `io` you essentially gain full control on what should happen
+ *                      with these streams. For a simple capturing processor, for example if you want to collect
+ *                      the output of the script, see {@link stdioCaptureProcessor}.
+ * @param exitOnError - If set to `true`, the process will exit with the exit code of the script.
+ */
+export declare function waitOnScript(module: string, args: string[], io?: StdioProcessor, exitOnError?: boolean): Promise<void>;
+export {};

package/cli/repl/execute.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.waitOnScript = exports.stdioCaptureProcessor = void 0;
+const child_process_1 = __importDefault(require("child_process"));
+const readline_1 = __importDefault(require("readline"));
+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.
+ */
+function stdioCaptureProcessor(stdio, onStdOutLine, onStdErrLine) {
+    (0, assert_1.guard)(stdio[1] !== null, 'no stdout given in stdio!');
+    const outRl = readline_1.default.createInterface({
+        input: stdio[1],
+        terminal: false
+    });
+    (0, assert_1.guard)(stdio[2] !== null, 'no stderr given in stdio!');
+    const errRl = readline_1.default.createInterface({
+        input: stdio[2],
+        terminal: false
+    });
+    outRl.on('line', onStdOutLine);
+    errRl.on('line', onStdErrLine);
+}
+exports.stdioCaptureProcessor = stdioCaptureProcessor;
+/**
+ * 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.
+ * @param args        - The arguments you want to start your process with.
+ * @param io          - If you omit this argument, the in-, out- and error-channels of the script execution
+ *                      will be automatically forwarded to the respective in-, out- and error-channels of your process.
+ *                      However, by defining `io` you essentially gain full control on what should happen
+ *                      with these streams. For a simple capturing processor, for example if you want to collect
+ *                      the output of the script, see {@link stdioCaptureProcessor}.
+ * @param exitOnError - If set to `true`, the process will exit with the exit code of the script.
+ */
+async function waitOnScript(module, args, io, exitOnError = false) {
+    log_1.log.info(`starting script ${module} with args ${JSON.stringify(args)}`);
+    const child = child_process_1.default.fork(module, args, {
+        silent: io !== undefined
+    });
+    if (io !== undefined) {
+        io(child.stdio);
+    }
+    child.on('exit', (code, signal) => {
+        if (code) {
+            console.error(`Script ${module} exited with code ${String(code)} and signal ${JSON.stringify(signal)}`);
+            if (exitOnError) {
+                process.exit(code);
+            }
+        }
+    });
+    child.on('error', err => {
+        console.error(`Script ${module} signaled error ${JSON.stringify(err)}`);
+        if (exitOnError) {
+            process.exit(1);
+        }
+    });
+    await new Promise((resolve, reject) => child.on('exit', code => {
+        if (exitOnError && code) {
+            reject(new Error(`Script ${module} exited with code ${String(code)}`));
+        }
+        else {
+            resolve();
+        }
+    }));
+}
+exports.waitOnScript = waitOnScript;
+//# sourceMappingURL=execute.js.map

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

@@ -0,0 +1,2 @@
+import type { RShell } from '../../r-bridge/shell';
+export declare function printVersionRepl(shell: RShell): Promise<void>;

package/cli/repl/print-version.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printVersionRepl = void 0;
+const version_1 = require("./commands/version");
+async function printVersionRepl(shell) {
+    const version = await (0, version_1.retrieveVersionInformation)(shell);
+    console.log(`flowR repl using flowR ${version.flowr}, R ${version.r}`);
+}
+exports.printVersionRepl = printVersionRepl;
+//# sourceMappingURL=print-version.js.map

package/cli/repl/prompt.d.ts

@@ -0,0 +1,2 @@
+export declare const rawPrompt = "R>";
+export declare const prompt: () => string;

package/cli/repl/prompt.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prompt = exports.rawPrompt = void 0;
+const ansi_1 = require("../../util/ansi");
+exports.rawPrompt = 'R>';
+// is a function as the 'formatter' is configured only after the cli options have been read
+const prompt = () => `${ansi_1.formatter.format(exports.rawPrompt, { color: 6 /* Colors.Cyan */, effect: ansi_1.ColorEffect.Foreground })} `;
+exports.prompt = prompt;
+//# sourceMappingURL=prompt.js.map

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

@@ -0,0 +1,21 @@
+import type { Socket } from './net';
+import type { RShell } from '../../../r-bridge/shell';
+/**
+ * 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.
+ */
+export declare class FlowRServerConnection {
+    private readonly socket;
+    private readonly shell;
+    private readonly name;
+    private readonly logger;
+    private readonly fileMap;
+    constructor(socket: Socket, name: string, shell: RShell);
+    private currentMessageBuffer;
+    private handleData;
+    private handleFileAnalysisRequest;
+    private sendFileAnalysisResponse;
+    private createPipelineExecutorForRequest;
+    private handleSliceRequest;
+    private handleRepl;
+}

package/cli/repl/server/connection.js

@@ -0,0 +1,218 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FlowRServerConnection = void 0;
+const send_1 = require("./send");
+const validate_1 = require("./validate");
+const analysis_1 = require("./messages/analysis");
+const slice_1 = require("./messages/slice");
+const server_1 = require("./server");
+const repl_1 = require("./messages/repl");
+const core_1 = require("../core");
+const pipeline_executor_1 = require("../../../core/pipeline-executor");
+const cfg_1 = require("../../../util/cfg/cfg");
+const quads_1 = require("../../../util/quads");
+const print_1 = require("../../../core/print/print");
+const _00_parse_1 = require("../../../core/steps/all/core/00-parse");
+const _10_normalize_1 = require("../../../core/steps/all/core/10-normalize");
+const _20_dataflow_1 = require("../../../core/steps/all/core/20-dataflow");
+const ansi_1 = require("../../../util/ansi");
+const default_pipelines_1 = require("../../../core/steps/pipeline/default-pipelines");
+/**
+ * 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.
+ */
+class FlowRServerConnection {
+    socket;
+    shell;
+    name;
+    logger;
+    // maps token to information
+    fileMap = new Map();
+    // we do not have to ensure synchronized shell-access as we are always running synchronized
+    constructor(socket, name, shell) {
+        this.socket = socket;
+        this.shell = shell;
+        this.name = name;
+        this.logger = server_1.serverLog.getSubLogger({ name });
+        this.socket.on('data', data => this.handleData(String(data)));
+        this.socket.on('error', e => this.logger.error(`[${this.name}] Error while handling connection: ${String(e)}`));
+    }
+    currentMessageBuffer = '';
+    handleData(message) {
+        if (!message.endsWith('\n')) {
+            this.currentMessageBuffer += message;
+            this.logger.trace(`[${this.name}] Received partial message. Buffering ${this.currentMessageBuffer.length}.`);
+            return;
+        }
+        message = this.currentMessageBuffer + message;
+        if (this.logger.settings.minLevel >= 2 /* LogLevel.Debug */) {
+            this.logger.debug(`[${this.name}] Received message: ${message}`);
+        }
+        this.currentMessageBuffer = '';
+        const request = (0, validate_1.validateBaseMessageFormat)(message);
+        if (request.type === 'error') {
+            (0, validate_1.answerForValidationError)(this.socket, request);
+            return;
+        }
+        switch (request.message.type) {
+            case 'request-file-analysis':
+                this.handleFileAnalysisRequest(request.message);
+                break;
+            case 'request-slice':
+                this.handleSliceRequest(request.message);
+                break;
+            case 'request-repl-execution':
+                this.handleRepl(request.message);
+                break;
+            default:
+                (0, send_1.sendMessage)(this.socket, {
+                    id: request.message.id,
+                    type: 'error',
+                    fatal: true,
+                    reason: `The message type ${JSON.stringify(request.message.type ?? 'undefined')} is not supported.`
+                });
+                this.socket.end();
+        }
+    }
+    handleFileAnalysisRequest(base) {
+        const requestResult = (0, validate_1.validateMessage)(base, analysis_1.requestAnalysisMessage);
+        if (requestResult.type === 'error') {
+            (0, validate_1.answerForValidationError)(this.socket, requestResult, base.id);
+            return;
+        }
+        const message = requestResult.message;
+        this.logger.info(`[${this.name}] Received file analysis request for ${message.filename ?? 'unknown file'}${message.filetoken ? ' with token: ' + message.filetoken : ''}`);
+        if (message.filetoken && this.fileMap.has(message.filetoken)) {
+            this.logger.warn(`File token ${message.filetoken} already exists. Overwriting.`);
+        }
+        const slicer = this.createPipelineExecutorForRequest(message);
+        void slicer.allRemainingSteps(false).then(async (results) => await this.sendFileAnalysisResponse(results, message))
+            .catch(e => {
+            this.logger.error(`[${this.name}] Error while analyzing file ${message.filename ?? 'unknown file'}: ${String(e)}`);
+            (0, send_1.sendMessage)(this.socket, {
+                id: message.id,
+                type: 'error',
+                fatal: false,
+                reason: `Error while analyzing file ${message.filename ?? 'unknown file'}: ${String(e)}`
+            });
+        });
+    }
+    async sendFileAnalysisResponse(results, message) {
+        let cfg = undefined;
+        if (message.cfg) {
+            cfg = (0, cfg_1.extractCFG)(results.normalize);
+        }
+        const config = () => ({ context: message.filename ?? 'unknown', getId: (0, quads_1.defaultQuadIdGenerator)() });
+        if (message.format === 'n-quads') {
+            (0, send_1.sendMessage)(this.socket, {
+                type: 'response-file-analysis',
+                format: 'n-quads',
+                id: message.id,
+                cfg: cfg ? (0, cfg_1.cfg2quads)(cfg, config()) : undefined,
+                results: {
+                    parse: await (0, print_1.printStepResult)(_00_parse_1.PARSE_WITH_R_SHELL_STEP, results.parse, 5 /* StepOutputFormat.RdfQuads */, config()),
+                    normalize: await (0, print_1.printStepResult)(_10_normalize_1.NORMALIZE, results.normalize, 5 /* StepOutputFormat.RdfQuads */, config()),
+                    dataflow: await (0, print_1.printStepResult)(_20_dataflow_1.STATIC_DATAFLOW, results.dataflow, 5 /* StepOutputFormat.RdfQuads */, config())
+                }
+            });
+        }
+        else {
+            (0, send_1.sendMessage)(this.socket, {
+                type: 'response-file-analysis',
+                format: 'json',
+                id: message.id,
+                cfg,
+                results: {
+                    ...results,
+                    normalize: {
+                        ...results.normalize,
+                        idMap: undefined
+                    }
+                }
+            });
+        }
+    }
+    createPipelineExecutorForRequest(message) {
+        const slicer = new pipeline_executor_1.PipelineExecutor(default_pipelines_1.DEFAULT_SLICING_PIPELINE, {
+            shell: this.shell,
+            // we have to make sure that the content is not interpreted as a file path if it starts with 'file://' therefore, we do it manually
+            request: {
+                request: message.content === undefined ? 'file' : 'text',
+                content: message.content ?? message.filepath
+            },
+            criterion: [] // currently unknown
+        });
+        if (message.filetoken) {
+            this.logger.info(`Storing file token ${message.filetoken}`);
+            this.fileMap.set(message.filetoken, {
+                filename: message.filename,
+                pipeline: slicer
+            });
+        }
+        return slicer;
+    }
+    handleSliceRequest(base) {
+        const requestResult = (0, validate_1.validateMessage)(base, slice_1.requestSliceMessage);
+        if (requestResult.type === 'error') {
+            (0, validate_1.answerForValidationError)(this.socket, requestResult, base.id);
+            return;
+        }
+        const request = requestResult.message;
+        this.logger.info(`[${request.filetoken}] Received slice request with criteria ${JSON.stringify(request.criterion)}`);
+        const fileInformation = this.fileMap.get(request.filetoken);
+        if (!fileInformation) {
+            (0, send_1.sendMessage)(this.socket, {
+                id: request.id,
+                type: 'error',
+                fatal: false,
+                reason: `The file token ${request.filetoken} has never been analyzed.`
+            });
+            return;
+        }
+        fileInformation.pipeline.updateRequest({ criterion: request.criterion });
+        void fileInformation.pipeline.allRemainingSteps(true).then(results => {
+            (0, send_1.sendMessage)(this.socket, {
+                type: 'response-slice',
+                id: request.id,
+                results: Object.fromEntries(Object.entries(results)
+                    .filter(([k,]) => default_pipelines_1.DEFAULT_SLICING_PIPELINE.steps.get(k)?.executed === 1 /* PipelineStepStage.OncePerRequest */))
+            });
+        }).catch(e => {
+            this.logger.error(`[${this.name}] Error while analyzing file for token ${request.filetoken}: ${String(e)}`);
+            (0, send_1.sendMessage)(this.socket, {
+                id: request.id,
+                type: 'error',
+                fatal: false,
+                reason: `Error while analyzing file for token ${request.filetoken}: ${String(e)}`
+            });
+        });
+    }
+    handleRepl(base) {
+        const requestResult = (0, validate_1.validateMessage)(base, repl_1.requestExecuteReplExpressionMessage);
+        if (requestResult.type === 'error') {
+            (0, validate_1.answerForValidationError)(this.socket, requestResult, base.id);
+            return;
+        }
+        const request = requestResult.message;
+        const out = (stream, msg) => {
+            (0, send_1.sendMessage)(this.socket, {
+                type: 'response-repl-execution',
+                id: request.id,
+                result: msg,
+                stream
+            });
+        };
+        void (0, core_1.replProcessAnswer)({
+            formatter: request.ansi ? ansi_1.ansiFormatter : ansi_1.voidFormatter,
+            stdout: msg => out('stdout', msg),
+            stderr: msg => out('stderr', msg)
+        }, request.expression, this.shell).then(() => {
+            (0, send_1.sendMessage)(this.socket, {
+                type: 'end-repl-execution',
+                id: request.id
+            });
+        });
+    }
+}
+exports.FlowRServerConnection = FlowRServerConnection;
+//# sourceMappingURL=connection.js.map