fenrir-runtime 0.0.1

package/Makefile

@@ -0,0 +1,16 @@
+.PHONY: install build all
+
+all: install build
+
+install:
+	@echo "Running npm install..."
+	npm install
+
+build:
+	@echo "Running npm run build..."
+	npm run build
+	@echo "Finish."
+
+clean:
+	@echo "Cleaning up node_modules and build files..."
+	rm -rf node_modules build dist

package/README.md

@@ -0,0 +1,89 @@
+# Fenrir Runtime
+
+
+
+**Fenrir** is a modern JavaScript runtime environment based on TypeScript.
+It provides developers with a fast, secure, and flexible working environment. Thanks to TypeScript support, it offers powerful type safety and a modern development experience. Fenrir is distributed as open source and is open to community contributions.
+
+---
+
+### Features
+
+- **TypeScript Compatibility:** Compatible with all TypeScript functions, making your projects more secure and sustainable.
+
+- **Rollback System:** Reduces the risk of errors by allowing you to undo changes.
+
+- **Modern Framework Support:** Works seamlessly with popular libraries such as Express, Koa, and Fastify.
+
+- **Open Source and Community-Focused:** You can review, modify, and contribute to the project.
+
+---
+
+### Installation
+
+Installing Fenrir is very easy. You can run the project by following the steps below:
+
+1. Clone the repository.
+```
+git clone https://github.com/yigitkabak/Fenrir
+```
+
+2. Enter the Project Directory.
+```
+cd Fenrir
+```
+
+3. Install and Compile Dependencies.
+```
+make
+```
+
+Or if you use Linux, you can download our application. [App](/App)
+
+Once the installation is complete, **Fenrir** is ready to use in your projects.
+
+---
+
+### Example Usage
+
+Creating a simple Express server with **Fenrir** is quite easy:
+
+```
+declare express from 'express'
+
+const app = express()
+const port = 3000
+
+fn handle_home_request(req, res) {
+  res.send('Hello from Fenrir Express!')
+}
+
+app.get('/', handle_home_request)
+
+fn start_server() {
+  app.listen(port, () => {
+    log(`Server running at http://localhost:${port}`)
+  })
+}
+
+start_server()
+```
+
+With this example, you can see the message **"Hello from Fenrir Express!"** by going to http://localhost:3000 in your browser.
+
+---
+### Contributing
+
+- **Fenrir** is a community-driven project. To contribute:
+
+1. **Use the project and provide feedback:** Report bugs or suggestions.
+
+2. **Contribute code:** Add new features or improve existing code.
+
+---
+
+NOTE: ⚠️ **Fenrir** is currently in BETA. You may encounter unexpected errors. Your feedback will greatly contribute to the development of the project.
+
+---
+## Licence
+**Fenrir** is licensed under the [GPL](LICENSE) Licence.

package/dist/archiveSystem.js

@@ -0,0 +1,219 @@
+import fs from 'fs-extra';
+import path from 'path';
+import crypto from 'crypto';
+import { execSync } from 'child_process';
+import { glob } from 'glob';
+export class ArchiveSystem {
+    projectRoot;
+    archiveDir;
+    constructor(projectRoot = process.cwd()) {
+        this.projectRoot = projectRoot;
+        this.archiveDir = path.join(projectRoot, '.fenrir', 'archives');
+    }
+    async createArchive(message) {
+        const now = new Date();
+        const timestamp = this.formatTimestamp(now);
+        const archivePath = path.join(this.archiveDir, timestamp);
+        await fs.ensureDir(archivePath);
+        const filesToArchive = await this.getFilesToArchive();
+        for (const file of filesToArchive) {
+            const srcPath = path.join(this.projectRoot, file);
+            const destPath = path.join(archivePath, file);
+            await fs.ensureDir(path.dirname(destPath));
+            await fs.copy(srcPath, destPath);
+        }
+        const metadata = {
+            timestamp: now.toISOString(),
+            message: message || 'Automatic archiving',
+            files: filesToArchive.length,
+            hash: this.generateHash(filesToArchive),
+            gitHash: await this.getGitHash().catch(() => null)
+        };
+        await fs.writeJSON(path.join(archivePath, '.metadata.json'), metadata, { spaces: 2 });
+        console.log(`Archive created: ${timestamp}`);
+        console.log(` ${filesToArchive.length}  file archived`);
+        console.log(`message: ${metadata.message}`);
+        return timestamp;
+    }
+    async listArchives() {
+        if (!fs.existsSync(this.archiveDir)) {
+            console.log('No archives have been created yet.');
+            return;
+        }
+        const archives = await fs.readdir(this.archiveDir);
+        archives.sort().reverse();
+        console.log('Archive history:');
+        for (const archive of archives.slice(0, 10)) {
+            const metadataPath = path.join(this.archiveDir, archive, '.metadata.json');
+            if (fs.existsSync(metadataPath)) {
+                const metadata = await fs.readJSON(metadataPath);
+                const date = new Date(metadata.timestamp);
+                console.log(` ${archive} - ${metadata.message}`);
+                console.log(` ${date.toLocaleString('en-US')}`);
+                console.log(` ${metadata.files} file`);
+                console.log('');
+            }
+        }
+        if (archives.length > 10) {
+            console.log(`   ... and ${archives.length - 10} archive more`);
+        }
+    }
+    async rollback(archiveId) {
+        if (!fs.existsSync(this.archiveDir)) {
+            console.log('Archive not found.');
+            return;
+        }
+        let targetArchive = archiveId;
+        if (!targetArchive) {
+            const archives = await fs.readdir(this.archiveDir);
+            archives.sort().reverse();
+            targetArchive = archives[0];
+        }
+        const archivePath = path.join(this.archiveDir, targetArchive);
+        if (!fs.existsSync(archivePath)) {
+            console.log(`Archive not found: ${targetArchive}`);
+            return;
+        }
+        console.log('Current status is being backed up...');
+        await this.createArchive(`Pre-rollback backup - ${new Date().toISOString()}`);
+        const metadataPath = path.join(archivePath, '.metadata.json');
+        const metadata = await fs.readJSON(metadataPath);
+        console.log(`${targetArchive} returning to archive...`);
+        console.log(` ${metadata.message}`);
+        const currentFiles = await this.getFilesToArchive();
+        for (const file of currentFiles) {
+            const filePath = path.join(this.projectRoot, file);
+            if (fs.existsSync(filePath)) {
+                await fs.remove(filePath);
+            }
+        }
+        const archiveFiles = await glob('**/*', {
+            cwd: archivePath,
+            nodir: true,
+            ignore: '.metadata.json'
+        });
+        for (const file of archiveFiles) {
+            const srcPath = path.join(archivePath, file);
+            const destPath = path.join(this.projectRoot, file);
+            await fs.ensureDir(path.dirname(destPath));
+            await fs.copy(srcPath, destPath);
+        }
+        console.log(`The return has been completed!`);
+        console.log(`${archiveFiles.length} file restored`);
+    }
+    async cleanArchives(keepCount = 10) {
+        if (!fs.existsSync(this.archiveDir)) {
+            return;
+        }
+        const archives = await fs.readdir(this.archiveDir);
+        archives.sort().reverse();
+        if (archives.length <= keepCount) {
+            console.log(`${archives.length} There is an archive, no cleaning is necessary.`);
+            return;
+        }
+        const toDelete = archives.slice(keepCount);
+        for (const archive of toDelete) {
+            await fs.remove(path.join(this.archiveDir, archive));
+        }
+        console.log(`${toDelete.length} The old archive has been cleared.`);
+        console.log(`${keepCount} The archive has been preserved.`);
+    }
+    formatTimestamp(date) {
+        return date.toISOString()
+            .replace(/T/, '_')
+            .replace(/:/g, '-')
+            .substring(0, 19);
+    }
+    async getFilesToArchive() {
+        const patterns = [
+            '**/*.py',
+            '**/*.pyc',
+            '**/*.pyo',
+            '**/*.java',
+            '**/*.class',
+            '**/*.jar',
+            '**/*.cpp',
+            '**/*.cxx',
+            '**/*.cc',
+            '**/*.c',
+            '**/*.hpp',
+            '**/*.h',
+            '**/*.hxx',
+            '**/*.cs',
+            '**/*.csproj',
+            '**/*.sln',
+            '**/*.rb',
+            '**/*.rake',
+            '**/*.php',
+            '**/*.phtml',
+            '**/*.php3',
+            '**/*.php4',
+            '**/*.php5',
+            '**/*.swift',
+            '**/*.go',
+            '**/*.rs',
+            '**/*.js',
+            '**/*.ts',
+            '**/*.jsx',
+            '**/*.tsx',
+            '**/*.mjs',
+            '**/*.cjs',
+            '**/*.css',
+            '**/*.scss',
+            '**/*.sass',
+            '**/*.less',
+            '**/*.html',
+            '**/*.htm',
+            '**/*.xhtml',
+            '**/*.json',
+            '**/*.xml',
+            '**/*.yml',
+            '**/*.yaml',
+            '**/*.md',
+            '**/*.markdown',
+            '**/*.mdown',
+            '**/*.txt',
+            '**/*.ini',
+            '**/*.conf',
+            '**/*.cfg',
+            '**/*.sh',
+            '**/*.bash',
+            '**/*.npm',
+            '**/*.lock',
+            '**/*.fnr'
+        ];
+        const ignorePatterns = [
+            '.fenrir/**',
+            'node_modules/**',
+            '.git/**',
+            '*.log',
+            '.DS_Store',
+            'Thumbs.db',
+            '.env*',
+            'dist/**',
+            'build/**',
+            '.cache/**'
+        ];
+        const files = [];
+        for (const pattern of patterns) {
+            const matches = await glob(pattern, {
+                cwd: this.projectRoot,
+                ignore: ignorePatterns,
+                nodir: true
+            });
+            files.push(...matches);
+        }
+        return [...new Set(files)].sort();
+    }
+    generateHash(files) {
+        const hash = crypto.createHash('md5');
+        hash.update(files.join('|'));
+        return hash.digest('hex').substring(0, 8);
+    }
+    async getGitHash() {
+        return execSync('git rev-parse HEAD', {
+            cwd: this.projectRoot,
+            encoding: 'utf8'
+        }).trim();
+    }
+}

package/dist/cli.js

@@ -0,0 +1,188 @@
+#!/usr/bin/env node
+import { spawn } from 'child_process';
+import path from 'path';
+import fs from 'fs-extra';
+import os from 'os';
+import { fileURLToPath } from 'url';
+import { transformFenrirCode } from './transformer.js';
+import { PackageManager } from './packageManager.js';
+import { ArchiveSystem } from './archiveSystem.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const command = process.argv[2];
+const args = process.argv.slice(3);
+const packageManager = new PackageManager();
+const archiveSystem = new ArchiveSystem();
+const executeCode = async (filePath) => {
+    try {
+        if (!await fs.pathExists(filePath)) {
+            console.error(`Error: File ${filePath} not found.`);
+            process.exit(1);
+        }
+        const fileContent = await fs.readFile(filePath, 'utf-8');
+        if (!fileContent.trim()) {
+            console.error('Error: The file is empty or contains only space characters.');
+            process.exit(1);
+        }
+        const aperiumConfig = fs.existsSync('fenrir.json')
+            ? JSON.parse(await fs.readFile('fenrir.json', 'utf8'))
+            : {};
+        const jsCode = await transformFenrirCode(fileContent, filePath, aperiumConfig.imports || {});
+        if (process.env.FENRIR_DEBUG) {
+            console.log('\nConverted JavaScript code:');
+            console.log(jsCode);
+        }
+        const tempDir = path.join(os.tmpdir(), `fenrir_temp_${Date.now()}`);
+        await fs.ensureDir(tempDir);
+        const tempFilePath = path.join(tempDir, 'runtime_output.mjs');
+        // node_modules kopyalama işlemini iyileştir
+        const originalNodeModulesPath = path.join(process.cwd(), 'node_modules');
+        const tempNodeModulesPath = path.join(tempDir, 'node_modules');
+        if (await fs.pathExists(originalNodeModulesPath)) {
+            try {
+                await fs.copy(originalNodeModulesPath, tempNodeModulesPath, {
+                    dereference: true,
+                    preserveTimestamps: false
+                });
+            }
+            catch (copyError) {
+                console.warn('Warning: Could not copy node_modules:', copyError?.message || copyError);
+            }
+        }
+        const originalPackageJsonPath = path.join(process.cwd(), 'package.json');
+        if (await fs.pathExists(originalPackageJsonPath)) {
+            try {
+                await fs.copy(originalPackageJsonPath, path.join(tempDir, 'package.json'));
+            }
+            catch (err) {
+                console.warn('Warning: Could not copy package.json:', err?.message || err);
+            }
+        }
+        const runtimePath = path.join(__dirname, 'runtime.js');
+        let finalCode = jsCode;
+        if (fs.existsSync(runtimePath)) {
+            const runtimeCode = await fs.readFile(runtimePath, 'utf8');
+            finalCode = `${runtimeCode}\n\n${jsCode}`;
+        }
+        await fs.writeFile(tempFilePath, finalCode);
+        const env = {
+            ...process.env,
+            NODE_PATH: [
+                path.join(tempDir, 'node_modules'),
+                path.join(process.cwd(), 'node_modules'),
+                process.env.NODE_PATH
+            ].filter(Boolean).join(path.delimiter)
+        };
+        if (process.env.FENRIR_DEBUG) {
+            console.log('Temp directory:', tempDir);
+            console.log('Original CWD:', process.cwd());
+            console.log('NODE_PATH:', env.NODE_PATH);
+            console.log('\nGenerated code:');
+            console.log('================');
+            console.log(finalCode);
+            console.log('================\n');
+        }
+        const child = spawn('node', [tempFilePath], {
+            stdio: 'inherit',
+            shell: false,
+            env: env,
+            cwd: process.cwd()
+        });
+        child.on('close', async (code) => {
+            try {
+                await fs.remove(tempDir);
+            }
+            catch (err) {
+            }
+            process.exit(code || 0);
+        });
+        child.on('error', async (err) => {
+            console.error('An error occurred while running Node.js:');
+            if (err.message.includes('SyntaxError')) {
+                console.error('Syntax error detected. Transformed code:');
+                finalCode.split('\n').forEach((line, index) => {
+                    console.error(`${(index + 1).toString().padStart(2, ' ')}: ${line}`);
+                });
+            }
+            else {
+                console.error(err);
+            }
+            try {
+                await fs.remove(tempDir);
+            }
+            catch (cleanupErr) {
+            }
+            process.exit(1);
+        });
+    }
+    catch (error) {
+        if (error instanceof SyntaxError) {
+            console.error('Syntax error:', error.message);
+        }
+        else {
+            console.error('An unexpected error occurred:', error);
+        }
+        process.exit(1);
+    }
+};
+const showHelp = () => {
+    console.log(`
+Fenrir Programming Language v0.0.1
+
+Usage:
+  fenrir <file.fnr>
+  fenrir install [package]
+  fenrir remove <package> 
+  fenrir archive [message]
+  fenrir archives
+  fenrir rollback [archive-id]
+  fenrir clean [number]
+  fenrir help
+`);
+};
+const run = async () => {
+    if (!command || command === 'help') {
+        showHelp();
+        return;
+    }
+    switch (command) {
+        case 'install':
+            await packageManager.install(args[0]);
+            break;
+        case 'remove':
+            if (!args[0]) {
+                console.error('Package name not specified.');
+                console.log('Usage: fenrir remove <package-name>');
+                process.exit(1);
+            }
+            await packageManager.remove(args[0]);
+            break;
+        case 'archive':
+            await archiveSystem.createArchive(args[0]);
+            break;
+        case 'archives':
+            await archiveSystem.listArchives();
+            break;
+        case 'rollback':
+            await archiveSystem.rollback(args[0]);
+            break;
+        case 'clean':
+            const keepCount = args[0] ? parseInt(args[0]) : 10;
+            await archiveSystem.cleanArchives(keepCount);
+            break;
+        default:
+            if (command.endsWith('.fnr')) {
+                const filePath = path.resolve(process.cwd(), command);
+                await executeCode(filePath);
+            }
+            else {
+                console.error(`Unknown command: ${command}`);
+                console.log('For help: fenrir help');
+                process.exit(1);
+            }
+    }
+};
+run().catch((error) => {
+    console.error('A critical error occurred while running the program:', error);
+    process.exit(1);
+});

package/dist/packageManager.js

@@ -0,0 +1,98 @@
+import { execSync } from 'child_process';
+import fs from 'fs-extra';
+import path from 'path';
+export class PackageManager {
+    projectRoot;
+    packageJsonPath;
+    fenrirJsonPath;
+    constructor(projectRoot = process.cwd()) {
+        this.projectRoot = projectRoot;
+        this.packageJsonPath = path.join(projectRoot, 'package.json');
+        this.fenrirJsonPath = path.join(projectRoot, 'fenrir.json');
+    }
+    async install(packageName) {
+        if (!fs.existsSync(this.fenrirJsonPath)) {
+            await this.initProject();
+        }
+        if (packageName) {
+            console.log(`${packageName} loading...`);
+            try {
+                execSync(`npm install ${packageName}`, {
+                    cwd: this.projectRoot,
+                    stdio: 'pipe'
+                });
+                await this.updateFenrirJson(packageName);
+                console.log(`${packageName} Successfully loaded!`);
+            }
+            catch (error) {
+                console.error(`${packageName} An error occurred while loading:`, error);
+                throw error;
+            }
+        }
+        else {
+            console.log('All dependencies are being loaded...');
+            execSync('npm install', {
+                cwd: this.projectRoot,
+                stdio: 'inherit'
+            });
+        }
+    }
+    async remove(packageName) {
+        console.log(` ${packageName} being removed...`);
+        try {
+            execSync(`npm uninstall ${packageName}`, {
+                cwd: this.projectRoot,
+                stdio: 'pipe'
+            });
+            await this.removeFomFenrirJson(packageName);
+            console.log(`${packageName} removed!`);
+        }
+        catch (error) {
+            console.error(`${packageName} An error occurred while removing:`, error);
+        }
+    }
+    async initProject() {
+        const projectName = path.basename(this.projectRoot);
+        const fenrirJson = {
+            name: projectName,
+            version: "0.0.1",
+            description: "A Fenrir project",
+            dependencies: {},
+            fenrirVersion: "0.0.1"
+        };
+        await fs.writeJSON(this.fenrirJsonPath, fenrirJson, { spaces: 2 });
+        if (!fs.existsSync(this.packageJsonPath)) {
+            const packageJson = {
+                name: projectName.toLowerCase().replace(/[^a-z0-9-]/g, '-'),
+                version: "0.0.1",
+                type: "module",
+                dependencies: {}
+            };
+            await fs.writeJSON(this.packageJsonPath, packageJson, { spaces: 2 });
+        }
+        console.log('The Fenrir project has been launched!');
+    }
+    async readFenrirJson() {
+        if (!fs.existsSync(this.fenrirJsonPath)) {
+            return { dependencies: {} };
+        }
+        return await fs.readJSON(this.fenrirJsonPath);
+    }
+    async updateFenrirJson(packageName) {
+        const fenrirJson = await this.readFenrirJson();
+        const packageJson = await fs.readJSON(this.packageJsonPath);
+        const version = packageJson.dependencies?.[packageName] || 'latest';
+        if (!fenrirJson.dependencies) {
+            fenrirJson.dependencies = {};
+        }
+        fenrirJson.dependencies[packageName] = version;
+        await fs.writeJSON(this.fenrirJsonPath, fenrirJson, { spaces: 2 });
+    }
+    async removeFomFenrirJson(packageName) {
+        const fenrirJson = await this.readFenrirJson();
+        if (fenrirJson.dependencies && fenrirJson.dependencies[packageName]) {
+            delete fenrirJson.dependencies[packageName];
+            await fs.writeJSON(this.fenrirJsonPath, fenrirJson, { spaces: 2 });
+        }
+    }
+}

package/dist/parser.js

@@ -0,0 +1,24 @@
+export const parse = (code) => {
+    const tokens = [];
+    const lines = code.split('\n');
+    for (const line of lines) {
+        if (line.trim().startsWith('fn')) {
+            tokens.push({ type: 'FN_DECL', value: line.trim() });
+            // DEĞİŞTİRİLDİ: Artık 'declare' kelimesini bir import beyanı olarak tanıyor
+        }
+        else if (line.trim().startsWith('declare')) {
+            tokens.push({ type: 'IMPORT_DECL', value: line.trim() });
+        }
+        else {
+            tokens.push({ type: 'EXPRESSION', value: line.trim() });
+        }
+    }
+    const ast = {
+        type: 'Program',
+        children: tokens.map(token => ({
+            type: token.type,
+            value: token.value
+        }))
+    };
+    return ast;
+};