@eagleoutice/flowr 2.5.0 → 2.6.1

package/search/search-executor/search-mappers.d.ts

@@ -1,19 +1,19 @@
-import type { FlowrSearchElement, FlowrSearchInput } from '../flowr-search';
+import type { FlowrSearchElement } from '../flowr-search';
 import type { ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { Enrichment } from './search-enrichers';
 import type { MergeableRecord } from '../../util/objects';
-import type { Pipeline } from '../../core/steps/pipeline/pipeline';
+import type { FlowrAnalysisProvider } from '../../project/flowr-analyzer';
 export declare enum Mapper {
     Enrichment = "enrichment"
 }
 export interface MapperData<Arguments extends string | MergeableRecord> {
-    mapper: (e: FlowrSearchElement<ParentInformation>, data: FlowrSearchInput<Pipeline>, args: Arguments) => FlowrSearchElement<ParentInformation>[];
+    mapper: (e: FlowrSearchElement<ParentInformation>, data: FlowrAnalysisProvider, args: Arguments) => FlowrSearchElement<ParentInformation>[];
 }
 export type MapperArguments<M extends Mapper> = typeof Mappers[M] extends MapperData<infer Arguments> ? Arguments : never;
 declare const Mappers: {
     readonly enrichment: {
-        mapper: (e: FlowrSearchElement<ParentInformation>, _data: FlowrSearchInput<Pipeline>, enrichment: Enrichment) => FlowrSearchElement<ParentInformation>[];
+        mapper: (e: FlowrSearchElement<ParentInformation>, _data: FlowrAnalysisProvider, enrichment: Enrichment) => FlowrSearchElement<ParentInformation>[];
     };
 };
-export declare function map<Element extends FlowrSearchElement<ParentInformation>, MapperType extends Mapper>(e: Element, data: FlowrSearchInput<Pipeline>, mapper: MapperType, args: MapperArguments<MapperType>): Element[];
+export declare function map<Element extends FlowrSearchElement<ParentInformation>, MapperType extends Mapper>(e: Element, data: FlowrAnalysisProvider, mapper: MapperType, args: MapperArguments<MapperType>): Element[];
 export {};

package/search/search-executor/search-transformer.d.ts

@@ -1,11 +1,11 @@
-import type { FlowrSearchElement, FlowrSearchElements, FlowrSearchInput, FlowrSearchTransformerNodeBase } from '../flowr-search';
-import type { Pipeline } from '../../core/steps/pipeline/pipeline';
+import type { FlowrSearchElement, FlowrSearchElements, FlowrSearchTransformerNodeBase } from '../flowr-search';
 import type { LastOfArray, Tail2TypesOrUndefined, TailOfArray } from '../../util/collections/arrays';
 import type { FlowrFilterExpression } from '../flowr-search-filters';
 import type { FlowrSearchGeneratorNode } from './search-generators';
 import type { ParentInformation } from '../../r-bridge/lang-4.x/ast/model/processing/decorate';
 import type { Enrichment, EnrichmentElementArguments } from './search-enrichers';
 import type { Mapper, MapperArguments } from './search-mappers';
+import type { FlowrAnalysisProvider } from '../../project/flowr-analyzer';
 /**
  * This is a union of all possible transformer node types
  */
@@ -37,35 +37,35 @@ export declare const transformers: {
 export declare function getTransformer<Name extends TransformerNames>(name: Name): typeof transformers[Name];
 /** If we already have no more elements, cascade will not add any but keep the empty elements, otherwise it will now be NewElements */
 type CascadeEmpty<Elements extends FlowrSearchElement<ParentInformation>[], NewElements extends FlowrSearchElement<ParentInformation>[]> = Elements extends [] ? FlowrSearchElements<ParentInformation, []> : FlowrSearchElements<ParentInformation, NewElements>;
-declare function getFirst<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE): CascadeEmpty<Elements, [Elements[0]]>;
-declare function getLast<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE): CascadeEmpty<Elements, [LastOfArray<Elements>]>;
-declare function getIndex<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE, { index }: {
+declare function getFirst<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrAnalysisProvider, elements: FSE): CascadeEmpty<Elements, [Elements[0]]>;
+declare function getLast<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrAnalysisProvider, elements: FSE): CascadeEmpty<Elements, [LastOfArray<Elements>]>;
+declare function getIndex<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrAnalysisProvider, elements: FSE, { index }: {
     index: number;
 }): CascadeEmpty<Elements, [Elements[number]]>;
-declare function getSelect<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE, { select }: {
+declare function getSelect<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrAnalysisProvider, elements: FSE, { select }: {
     select: number[];
 }): CascadeEmpty<Elements, Elements>;
-declare function getTail<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE): CascadeEmpty<Elements, TailOfArray<Elements>>;
-declare function getTake<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE, { count }: {
+declare function getTail<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrAnalysisProvider, elements: FSE): CascadeEmpty<Elements, TailOfArray<Elements>>;
+declare function getTake<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrAnalysisProvider, elements: FSE, { count }: {
     count: number;
 }): CascadeEmpty<Elements, TailOfArray<Elements>>;
-declare function getSkip<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE, { count }: {
+declare function getSkip<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrAnalysisProvider, elements: FSE, { count }: {
     count: number;
 }): CascadeEmpty<Elements, TailOfArray<Elements>>;
-declare function getFilter<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE, { filter }: {
+declare function getFilter<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrAnalysisProvider, elements: FSE, { filter }: {
     filter: FlowrFilterExpression;
-}): CascadeEmpty<Elements, Elements | []>;
-declare function getWith<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE, { info, args }: {
+}): Promise<CascadeEmpty<Elements, Elements | []>>;
+declare function getWith<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(input: FlowrAnalysisProvider, elements: FSE, { info, args }: {
     info: Enrichment;
     args?: EnrichmentElementArguments<Enrichment>;
-}): FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>;
-declare function getMap<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE, { mapper, args }: {
+}): Promise<FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>>;
+declare function getMap<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrAnalysisProvider, elements: FSE, { mapper, args }: {
     mapper: Mapper;
     args: MapperArguments<Mapper>;
 }): FlowrSearchElements<ParentInformation, Elements>;
-declare function getMerge<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE, other: {
+declare function getMerge<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrAnalysisProvider, elements: FSE, other: {
     search: unknown[];
     generator: FlowrSearchGeneratorNode;
-}): FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>;
-declare function getUnique<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrSearchInput<Pipeline>, elements: FSE): CascadeEmpty<Elements, Elements>;
+}): Promise<FlowrSearchElements<ParentInformation, FlowrSearchElement<ParentInformation>[]>>;
+declare function getUnique<Elements extends FlowrSearchElement<ParentInformation>[], FSE extends FlowrSearchElements<ParentInformation, Elements>>(data: FlowrAnalysisProvider, elements: FSE): CascadeEmpty<Elements, Elements>;
 export {};

package/search/search-executor/search-transformer.js

@@ -92,19 +92,26 @@ function getTake(data, elements, { count }) {
 function getSkip(data, elements, { count }) {
     return elements.mutate(e => sortFully(e).slice(count));
 }
-function getFilter(data, elements, { filter }) {
-    return elements.mutate(e => e.filter(e => (0, flowr_search_filters_1.evalFilter)(filter, { element: e, data })));
-}
-function getWith(data, elements, { info, args }) {
-    return elements.enrich(data, info, args).mutate(s => s.map(e => (0, search_enrichers_1.enrichElement)(e, elements, data, info, args)));
+async function getFilter(data, elements, { filter }) {
+    const dataflow = await data.dataflow();
+    return elements.mutate(e => e.filter(e => (0, flowr_search_filters_1.evalFilter)(filter, { element: e, data: { dataflow } })));
+}
+async function getWith(input, elements, { info, args }) {
+    const data = {
+        normalize: await input.normalize(),
+        dataflow: await input.dataflow(),
+        cfg: await input.controlflow(),
+        config: input.flowrConfig
+    };
+    return (await elements.enrich(input, info, args)).mutate(async (s) => await Promise.all(s.map(e => (0, search_enrichers_1.enrichElement)(e, elements, data, info, args))));
 }
 function getMap(data, elements, { mapper, args }) {
     return elements.mutate(elements => elements.flatMap(e => (0, search_mappers_1.map)(e, data, mapper, args)));
 }
-function getMerge(
+async function getMerge(
 /* search has to be unknown because it is a recursive type */
 data, elements, other) {
-    const resultOther = (0, flowr_search_executor_1.runSearch)(other, data);
+    const resultOther = await (0, flowr_search_executor_1.runSearch)(other, data);
     return elements.addAll([...resultOther.getElements()]);
 }
 function getUnique(data, elements) {

package/util/collections/arrays.d.ts

@@ -90,3 +90,4 @@ export declare function equidistantSampling<T>(list: readonly T[], sampleCount:
 export declare function cartesianProduct<T>(...arrays: T[][]): T[][];
 /** merge two arrays, removing duplicates */
 export declare function uniqueArrayMerge<T>(left: readonly T[], right: readonly T[]): T[];
+export declare function arraysGroupBy<T, K>(arr: readonly T[], keyFn: (elem: T) => K): Map<K, T[]>;

package/util/collections/arrays.js

@@ -11,6 +11,7 @@ exports.arrayEqual = arrayEqual;
 exports.equidistantSampling = equidistantSampling;
 exports.cartesianProduct = cartesianProduct;
 exports.uniqueArrayMerge = uniqueArrayMerge;
+exports.arraysGroupBy = arraysGroupBy;
 const assert_1 = require("../assert");
 /**
  * Splits the array every time the given predicate fires.
@@ -224,4 +225,18 @@ function uniqueArrayMerge(left, right) {
     }
     return Array.from(result);
 }
+function arraysGroupBy(arr, keyFn) {
+    const result = new Map();
+    for (const elem of arr) {
+        const key = keyFn(elem);
+        const group = result.get(key);
+        if (group) {
+            group.push(elem);
+        }
+        else {
+            result.set(key, [elem]);
+        }
+    }
+    return result;
+}
 //# sourceMappingURL=arrays.js.map

package/util/collections/objectmap.d.ts

@@ -0,0 +1,17 @@
+/**
+ * A map type that accepts an arbitrary object as key.
+ * {@link JSON.stringify} is used to create the actual key for the underlying map.
+ * This can be helpful if value equality is desired.
+ */
+export declare class ObjectMap<K, V> {
+    private readonly internal;
+    private makeKey;
+    /**
+     * Sets a value for a given key.
+     */
+    set(key: K, v: V): void;
+    /**
+     * Return the value for the key.
+     */
+    get(key: K): V | undefined;
+}

package/util/collections/objectmap.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectMap = void 0;
+/**
+ * A map type that accepts an arbitrary object as key.
+ * {@link JSON.stringify} is used to create the actual key for the underlying map.
+ * This can be helpful if value equality is desired.
+ */
+class ObjectMap {
+    internal = new Map();
+    makeKey(key) {
+        return JSON.stringify(key);
+    }
+    /**
+     * Sets a value for a given key.
+     */
+    set(key, v) {
+        this.internal.set(this.makeKey(key), v);
+    }
+    /**
+     * Return the value for the key.
+     */
+    get(key) {
+        return this.internal.get(this.makeKey(key));
+    }
+}
+exports.ObjectMap = ObjectMap;
+//# sourceMappingURL=objectmap.js.map

package/util/containers.d.ts

@@ -17,7 +17,6 @@ export declare function getAccessOperands<OtherInfo>(args: readonly RFunctionArg
  *
  * @param name - Name to resolve
  * @param environment - Environment in which name is resolved
- * @param builtInEnvironment - Built-in environment
  * @returns The indicesCollection of the resolved definitions
  */
 export declare function resolveIndicesByName(name: Identifier, environment: REnvironmentInformation): ContainerIndices[] | undefined;

package/util/containers.js

@@ -24,7 +24,6 @@ function getAccessOperands(args) {
  *
  * @param name - Name to resolve
  * @param environment - Environment in which name is resolved
- * @param builtInEnvironment - Built-in environment
  * @returns The indicesCollection of the resolved definitions
  */
 function resolveIndicesByName(name, environment) {

package/util/files.d.ts

@@ -1,4 +1,6 @@
+import type { PathLike } from 'fs';
 import type { RParseRequestFromFile } from '../r-bridge/retriever';
+import type { FlowrFileProvider } from '../project/context/flowr-file';
 /**
  * Represents a table, identified by a header and a list of rows.
  */
@@ -11,8 +13,16 @@ export interface Table {
  * @param dir    - Directory path to start the search from
  * @param suffix - Suffix of the files to be retrieved
  * Based on {@link https://stackoverflow.com/a/45130990}
+ *
+ * @see {@link getAllFilesSync} for a synchronous version.
  */
 export declare function getAllFiles(dir: string, suffix?: RegExp): AsyncGenerator<string>;
+/**
+ * Retrieves all files in the given directory recursively (synchronously)
+ *
+ * @see {@link getAllFiles} - for an asynchronous version.
+ */
+export declare function getAllFilesSync(dir: string, suffix?: RegExp): Generator<string>;
 /**
  * Retrieves all R files in a given directory (asynchronously)
  *
@@ -63,3 +73,10 @@ export declare function readLineByLineSync(filePath: string, onLine: (line: Buff
  * @param directory - The directory whose parent to return
  */
 export declare function getParentDirectory(directory: string): string;
+/**
+ * Parses the given file in the 'Debian Control Format'.
+ * @param file - The file to parse
+ * @returns Map containing the keys and values of the provided file.
+ */
+export declare function parseDCF(file: FlowrFileProvider<string>): Map<string, string[]>;
+export declare function isFilePath(p: PathLike): boolean;

package/util/files.js

@@ -37,12 +37,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getAllFiles = getAllFiles;
+exports.getAllFilesSync = getAllFilesSync;
 exports.allRFiles = allRFiles;
 exports.allRFilesFrom = allRFilesFrom;
 exports.writeTableAsCsv = writeTableAsCsv;
 exports.readLineByLine = readLineByLine;
 exports.readLineByLineSync = readLineByLineSync;
 exports.getParentDirectory = getParentDirectory;
+exports.parseDCF = parseDCF;
+exports.isFilePath = isFilePath;
 const fs_1 = __importStar(require("fs"));
 const path_1 = __importDefault(require("path"));
 const log_1 = require("./log");
@@ -52,6 +55,8 @@ const n_readlines_1 = __importDefault(require("n-readlines"));
  * @param dir    - Directory path to start the search from
  * @param suffix - Suffix of the files to be retrieved
  * Based on {@link https://stackoverflow.com/a/45130990}
+ *
+ * @see {@link getAllFilesSync} for a synchronous version.
  */
 async function* getAllFiles(dir, suffix = /.*/) {
     const entries = await fs_1.promises.readdir(dir, { withFileTypes: true, recursive: false });
@@ -65,6 +70,23 @@ async function* getAllFiles(dir, suffix = /.*/) {
         }
     }
 }
+/**
+ * Retrieves all files in the given directory recursively (synchronously)
+ *
+ * @see {@link getAllFiles} - for an asynchronous version.
+ */
+function* getAllFilesSync(dir, suffix = /.*/) {
+    const entries = fs_1.default.readdirSync(dir, { withFileTypes: true, recursive: false });
+    for (const subEntries of entries) {
+        const res = path_1.default.resolve(dir, subEntries.name);
+        if (subEntries.isDirectory()) {
+            yield* getAllFilesSync(res, suffix);
+        }
+        else if (suffix.test(subEntries.name)) {
+            yield res;
+        }
+    }
+}
 const rFileRegex = /\.[rR]$/;
 /**
  * Retrieves all R files in a given directory (asynchronously)
@@ -182,4 +204,47 @@ function getParentDirectory(directory) {
     // apparently this is somehow the best way to do it in node, what
     return directory.split(path_1.default.sep).slice(0, -1).join(path_1.default.sep);
 }
+/**
+ * Parses the given file in the 'Debian Control Format'.
+ * @param file - The file to parse
+ * @returns Map containing the keys and values of the provided file.
+ */
+function parseDCF(file) {
+    const result = new Map();
+    let currentKey = '';
+    let currentValue = '';
+    const indentRegex = new RegExp(/^\s/);
+    const firstColonRegex = new RegExp(/:(.*)/s);
+    const fileContent = file.content().split(/\r?\n/);
+    for (const line of fileContent) {
+        if (indentRegex.test(line)) {
+            currentValue += '\n' + line.trim();
+        }
+        else {
+            if (currentKey) {
+                const values = currentValue ? cleanValues(currentValue) : [];
+                result.set(currentKey, values);
+            }
+            const [key, rest] = line.split(firstColonRegex).map(s => s.trim());
+            currentKey = key.trim();
+            currentValue = rest.trim();
+        }
+    }
+    if (currentKey) {
+        const values = currentValue ? cleanValues(currentValue) : [];
+        result.set(currentKey, values);
+    }
+    return result;
+}
+const cleanSplitRegex = /[\n,]+/;
+const cleanQuotesRegex = /'/g;
+function cleanValues(values) {
+    return values
+        .split(cleanSplitRegex)
+        .map(s => s.trim().replace(cleanQuotesRegex, ''))
+        .filter(s => s.length > 0);
+}
+function isFilePath(p) {
+    return fs_1.default.existsSync(p) && fs_1.default.statSync(p).isFile();
+}
 //# sourceMappingURL=files.js.map

package/util/formats/adapter.d.ts

@@ -1,10 +1,11 @@
-import type { RParseRequest } from '../../r-bridge/retriever';
+import type { RParseRequest, RParseRequestFromText } from '../../r-bridge/retriever';
+import type { SupportedFormats } from './adapter-format';
 export declare const FileAdapters: {
     readonly R: {
         convertRequest: (request: RParseRequest) => RParseRequest;
     };
     readonly Rmd: {
-        convertRequest: (request: RParseRequest) => import("../../r-bridge/retriever").RParseRequestFromText<import("./adapters/rmd-adapter").RmdInfo>;
+        convertRequest: (request: RParseRequest) => RParseRequestFromText<import("./adapters/rmd-adapter").RmdInfo>;
     };
 };
 export declare const DocumentTypeToFormat: {
@@ -13,4 +14,5 @@ export declare const DocumentTypeToFormat: {
 };
 export type AdapterReturnTypes = ReturnType<typeof FileAdapters[keyof typeof FileAdapters]['convertRequest']>;
 export declare function requestFromFile(path: string): AdapterReturnTypes;
+export declare function requestFromText(text: string, typeHint?: SupportedFormats): AdapterReturnTypes;
 export declare function inferFileType(request: RParseRequest): keyof typeof FileAdapters;

package/util/formats/adapter.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DocumentTypeToFormat = exports.FileAdapters = void 0;
 exports.requestFromFile = requestFromFile;
+exports.requestFromText = requestFromText;
 exports.inferFileType = inferFileType;
 const r_adapter_1 = require("./adapters/r-adapter");
 const path_1 = __importDefault(require("path"));
@@ -25,12 +26,18 @@ function requestFromFile(path) {
     const type = inferFileType(baseRequest);
     return exports.FileAdapters[type].convertRequest(baseRequest);
 }
+function requestFromText(text, typeHint) {
+    const baseRequest = {
+        request: 'text',
+        content: text,
+        info: typeHint ? { type: typeHint } : undefined
+    };
+    const type = inferFileType(baseRequest);
+    return exports.FileAdapters[type].convertRequest(baseRequest);
+}
 function inferFileType(request) {
     if (request.request === 'text') {
-        // For now we don't know what type the request is 
-        // and have to assume it is normal R Code
-        // In the future we could add a heuristic to guess the type
-        return 'R';
+        return request.info ? request.info.type : 'R';
     }
     const type = path_1.default.extname(request.content).toLowerCase();
     // Fallback to default if unknown

package/util/r-value.d.ts

@@ -20,4 +20,4 @@ export declare function unliftRValue(value: ValueString): RStringValue | undefin
 export declare function unliftRValue(value: ValueNumber | ValueInterval): RNumberValue | undefined;
 export declare function unliftRValue(value: ValueLogical): RLogicalValue | undefined;
 export declare function unliftRValue(value: ValueVector): (RStringValue | RNumberValue | RLogicalValue)[] | undefined;
-export declare function unliftRValue(value: Value): RStringValue | RNumberValue | boolean | (RStringValue | RNumberValue | RLogicalValue)[] | undefined;
+export declare function unliftRValue(value: Value): RStringValue | RNumberValue | 'fn-def' | boolean | ('fn-def' | RStringValue | RNumberValue | RLogicalValue)[] | undefined;

package/util/r-value.js

@@ -106,6 +106,8 @@ function unliftRValue(value) {
         case 'missing': {
             return undefined;
         }
+        case 'function-definition':
+            return 'fn-def';
         default:
             (0, assert_1.assertUnreachable)(type);
     }

package/util/version.d.ts

@@ -1,2 +1,19 @@
 import { SemVer } from 'semver';
+import type { KnownParser } from '../r-bridge/parser';
+import type { ReplOutput } from '../cli/repl/commands/repl-main';
+import type { FlowrAnalysisProvider } from '../project/flowr-analyzer';
 export declare function flowrVersion(): SemVer;
+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(input: KnownParser | FlowrAnalysisProvider): Promise<VersionInformation>;
+export declare function printVersionInformation(output: ReplOutput, input: KnownParser | FlowrAnalysisProvider): Promise<void>;
+export {};

package/util/version.js

@@ -1,10 +1,37 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.flowrVersion = flowrVersion;
+exports.retrieveVersionInformation = retrieveVersionInformation;
+exports.printVersionInformation = printVersionInformation;
 const semver_1 = require("semver");
+const assert_1 = require("./assert");
 // this is automatically replaced with the current version by release-it
-const version = '2.5.0';
+const version = '2.6.1';
 function flowrVersion() {
     return new semver_1.SemVer(version);
 }
+const versionRegex = /^\d+\.\d+\.\d+/m;
+async function retrieveVersionInformation(input) {
+    const flowr = flowrVersion().toString();
+    let r;
+    let name;
+    if ('name' in input) {
+        r = await input.rVersion();
+        name = input.name;
+    }
+    else {
+        const parserInformation = await input.parserInformation();
+        r = parserInformation.name === 'r-shell' ? parserInformation.rVersion : 'unknown';
+        name = parserInformation.name;
+    }
+    (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: name };
+}
+async function printVersionInformation(output, input) {
+    const { flowr, r, engine } = await retrieveVersionInformation(input);
+    output.stdout(`Engine: ${engine}`);
+    output.stdout(` flowR: ${flowr}`);
+    output.stdout(` R: ${r}`);
+}
 //# sourceMappingURL=version.js.map