fenrir-runtime 0.0.1 → 0.2.0

package/README.md

@@ -1,89 +0,0 @@
-# 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

@@ -1,219 +0,0 @@
-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

@@ -1,188 +0,0 @@
-#!/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

@@ -1,98 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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;
-};