fenrir-runtime 0.0.1

package/example/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "example",
+  "version": "1.0.0",
+  "description": "",
+  "main": "main.fnr",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "GPL",
+  "type": "module",
+  "dependencies": {
+    "express": "^5.1.0",
+    "fs-extra": "^11.3.1"
+  }
+}

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "fenrir-runtime",
+  "version": "0.0.1",
+  "description": "Fenrir Runtime",
+  "main": "dist/cli.js",
+  "bin": {
+    "fenrir": "./dist/cli.js"
+  },
+  "type": "module",
+  "scripts": {
+    "build": "tsc && npm link",
+    "dev": "tsc --watch",
+    "test": "node dist/test.js"
+  },
+  "keywords": [
+    "fenrir",
+    "runtime",
+    "typescript",
+    "version-control"
+  ],
+  "author": "openbyte.",
+  "license": "GPL-3 or later",
+  "dependencies": {
+    "fs-extra": "^11.2.0",
+    "glob": "^10.3.10"
+  },
+  "devDependencies": {
+    "@types/fs-extra": "^11.0.4",
+    "@types/node": "^20.10.6",
+    "typescript": "^5.3.3"
+  }
+}

package/src/archiveSystem.ts

@@ -0,0 +1,264 @@
+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 {
+    private projectRoot: string;
+    private archiveDir: string;
+
+    constructor(projectRoot: string = process.cwd()) {
+        this.projectRoot = projectRoot;
+        this.archiveDir = path.join(projectRoot, '.fenrir', 'archives');
+    }
+
+    async createArchive(message?: string): Promise<string> {
+        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(): Promise<void> {
+        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?: string): Promise<void> {
+        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: number = 10): Promise<void> {
+        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.`);
+    }
+
+    private formatTimestamp(date: Date): string {
+        return date.toISOString()
+            .replace(/T/, '_')
+            .replace(/:/g, '-')
+            .substring(0, 19);
+    }
+
+    private async getFilesToArchive(): Promise<string[]> {
+        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: string[] = [];
+        
+        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();
+    }
+
+    private generateHash(files: string[]): string {
+        const hash = crypto.createHash('md5');
+        hash.update(files.join('|'));
+        return hash.digest('hex').substring(0, 8);
+    }
+
+    private async getGitHash(): Promise<string> {
+        return execSync('git rev-parse HEAD', { 
+            cwd: this.projectRoot,
+            encoding: 'utf8' 
+        }).trim();
+    }
+}

package/src/cli.ts

@@ -0,0 +1,216 @@
+#!/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: string) => {
+    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: any) {
+                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: any) {
+                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: any) => {
+            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: string, index: number) => {
+                    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/src/packageManager.ts

@@ -0,0 +1,119 @@
+import { execSync } from 'child_process';
+import fs from 'fs-extra';
+import path from 'path';
+
+export class PackageManager {
+    private projectRoot: string;
+    private packageJsonPath: string;
+    private fenrirJsonPath: string;
+
+    constructor(projectRoot: string = process.cwd()) {
+        this.projectRoot = projectRoot;
+        this.packageJsonPath = path.join(projectRoot, 'package.json');
+        this.fenrirJsonPath = path.join(projectRoot, 'fenrir.json');
+    }
+
+    async install(packageName?: string): Promise<void> {
+        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: string): Promise<void> {
+        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);
+        }
+    }
+    
+    private async initProject(): Promise<void> {
+        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!');
+    }
+
+    private async readFenrirJson(): Promise<any> {
+        if (!fs.existsSync(this.fenrirJsonPath)) {
+            return { dependencies: {} };
+        }
+        return await fs.readJSON(this.fenrirJsonPath);
+    }
+
+    private async updateFenrirJson(packageName: string): Promise<void> {
+        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 });
+    }
+
+    private async removeFomFenrirJson(packageName: string): Promise<void> {
+        const fenrirJson = await this.readFenrirJson();
+        
+        if (fenrirJson.dependencies && fenrirJson.dependencies[packageName]) {
+            delete fenrirJson.dependencies[packageName];
+            await fs.writeJSON(this.fenrirJsonPath, fenrirJson, { spaces: 2 });
+        }
+    }
+}

package/src/parser.ts

@@ -0,0 +1,36 @@
+interface Token {
+  type: string;
+  value: string;
+}
+
+interface ASTNode {
+  type: string;
+  value?: any;
+  children?: ASTNode[];
+}
+
+export const parse = (code: string): ASTNode => {
+  const tokens: Token[] = [];
+  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: ASTNode = {
+    type: 'Program',
+    children: tokens.map(token => ({
+      type: token.type,
+      value: token.value
+    }))
+  };
+
+  return ast;
+};