fenrir-runtime 0.0.1 → 0.3.0

package/src/packageManager.ts

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

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

package/src/runtime.ts

@@ -1,111 +0,0 @@
-import { execSync, spawn } from 'child_process';
-import fs from 'fs-extra';
-import path from 'path';
-import os from 'os';
-
-export class FenrirRuntime {
-    private static instance: FenrirRuntime;
-    private packageCache = new Map<string, any>();
-    private runtimeCache = new Map<string, Function>();
-
-    static getInstance(): FenrirRuntime {
-        if (!FenrirRuntime.instance) {
-            FenrirRuntime.instance = new FenrirRuntime();
-        }
-        return FenrirRuntime.instance;
-    }
-
-    log = (...args: any[]): void => {
-        process.stdout.write(args.map(arg => 
-            typeof arg === 'object' ? JSON.stringify(arg, null, 2) : String(arg)
-        ).join(' ') + '\n');
-    }
-
-    readFile = (filePath: string): string => {
-        try {
-            return fs.readFileSync(path.resolve(filePath), 'utf8');
-        } catch (error) {
-            throw new Error(`File cannot be read: ${filePath}`);
-        }
-    }
-
-    writeFile = (filePath: string, content: string): void => {
-        try {
-            fs.writeFileSync(path.resolve(filePath), content, 'utf8');
-        } catch (error) {
-            throw new Error(`File could not be written: ${filePath}`);
-        }
-    }
-
-    fetch = async (url: string, options?: any): Promise<any> => {
-        const https = require('https');
-        const http = require('http');
-        
-        return new Promise((resolve, reject) => {
-            const client = url.startsWith('https') ? https : http;
-            const req = client.get(url, (res: any) => {
-                let data = '';
-                res.on('data', (chunk: any) => data += chunk);
-                res.on('end', () => {
-                    try {
-                        resolve(JSON.parse(data));
-                    } catch {
-                        resolve(data);
-                    }
-                });
-            });
-            req.on('error', reject);
-        });
-    }
-
-    require = (packageName: string): any => {
-        if (this.packageCache.has(packageName)) {
-            return this.packageCache.get(packageName);
-        }
-
-        try {
-            const pkg = require(packageName);
-            this.packageCache.set(packageName, pkg);
-            return pkg;
-        } catch (error) {
-            throw new Error(`Package not found: ${packageName}. Install it with the command 'fenrir install ${packageName}'.`);
-        }
-    }
-
-    exec = (command: string): string => {
-        try {
-            return execSync(command, { encoding: 'utf8', stdio: 'inherit' });
-        } catch (error) {
-            throw new Error(`Command could not be executed: ${command}`);
-        }
-    }
-    
-    executeCommand = (command: string): string => {
-        try {
-            return execSync(command, { encoding: 'utf8', stdio: 'inherit' });
-        } catch (error) {
-            const errorMessage = (error as any).message || 'Bilinmeyen bir hata oluştu.';
-            throw new Error(`Fenrir komutu çalıştırılamadı: ${command}. Hata: ${errorMessage}`);
-        }
-    }
-
-    now = (): number => Date.now()
-    time = (): string => new Date().toISOString()
-    sleep = (ms: number): Promise<void> => new Promise(resolve => setTimeout(resolve, ms))
-}
-
-const fenrirRuntime = FenrirRuntime.getInstance();
-
-Object.assign(globalThis, { 
-    fenrir: fenrirRuntime.executeCommand,
-    log: fenrirRuntime.log,
-    readFile: fenrirRuntime.readFile,
-    writeFile: fenrirRuntime.writeFile,
-    fetch: fenrirRuntime.fetch,
-    exec: fenrirRuntime.exec,
-    now: fenrirRuntime.now,
-    sleep: fenrirRuntime.sleep
-});
-
-export { fenrirRuntime as fenrir };
-export default FenrirRuntime;

package/src/transformer.ts

@@ -1,147 +0,0 @@
-import path from 'path';
-import fs from 'fs';
-
-export const transformFenrirCode = async (fenrirCode: string, filePath: string, aperiumImports: { [key: string]: string }): Promise<string> => {
-    
-    if (fenrirCode.includes('import ')) {
-        throw new Error("Fenrir Error: The keyword 'import' cannot be used. Use 'declare' to identify modules.");
-    }
-
-    const lines = fenrirCode.split('\n');
-    let jsOutput = '';
-    let i = 0;
-
-    while (i < lines.length) {
-        const line = lines[i];
-        const trimmedLine = line.trim();
-        
-        if (!trimmedLine) {
-            jsOutput += line + '\n';
-            i++;
-            continue;
-        }
-
-        let transformedLine = trimmedLine;
-        let isMultiLineStatement = false;
-
-        if (trimmedLine.startsWith('fn ')) {
-            transformedLine = transformedLine.replace(/^fn\s+/, 'function ');
-        }
-        else if (trimmedLine.startsWith('declare ')) {
-            const importMatch = trimmedLine.match(/declare\s+(.*?)\s+from\s+['"](.*?)['"]/);
-            if (importMatch) {
-                const importName = importMatch[1];
-                const modulePath = importMatch[2];
-                
-                if (isNpmModule(modulePath)) {
-                    transformedLine = `import ${importName} from "${modulePath}";`;
-                } else {
-                    const resolvedPath = path.resolve(path.dirname(filePath), modulePath);
-                    transformedLine = `import ${importName} from "file://${resolvedPath}";`;
-                }
-            }
-        }
-
-        transformedLine = transformedLine.replace(/\blog\(/g, 'console.log(');
-
-        if (transformedLine.includes('(') && !transformedLine.includes(')')) {
-            isMultiLineStatement = true;
-            let fullStatement = transformedLine;
-            let j = i + 1;
-            let openParens = (transformedLine.match(/\(/g) || []).length;
-            let closeParens = (transformedLine.match(/\)/g) || []).length;
-
-            while (j < lines.length && openParens > closeParens) {
-                const nextLine = lines[j];
-                fullStatement += '\n' + nextLine;
-                openParens += (nextLine.match(/\(/g) || []).length;
-                closeParens += (nextLine.match(/\)/g) || []).length;
-                j++;
-            }
-
-            const processedStatement = fullStatement.replace(/\blog\(/g, 'console.log(');
-            
-            if (shouldAddSemicolon(processedStatement.trim())) {
-                jsOutput += processedStatement + ';\n';
-            } else {
-                jsOutput += processedStatement + '\n';
-            }
-            
-            i = j;
-            continue;
-        }
-
-        if (shouldAddSemicolon(transformedLine)) {
-            transformedLine += ';';
-        }
-        
-        jsOutput += transformedLine + '\n';
-        i++;
-    }
-
-    return jsOutput;
-};
-
-function isNpmModule(modulePath: string): boolean {
-    if (modulePath.startsWith('./') || modulePath.startsWith('../')) {
-        return false;
-    }
-    
-    if (modulePath.startsWith('/')) {
-        return false;
-    }
-    
-    if (modulePath.match(/\.(js|mjs|ts|json)$/)) {
-        return false;
-    }
-    
-    return true;
-}
-
-function shouldAddSemicolon(line: string): boolean {
-    const trimmed = line.trim();
-    
-    if (trimmed.endsWith(';')) return false;
-    
-    if (trimmed.endsWith('{') || 
-        trimmed.endsWith('}') || 
-        (trimmed.endsWith(')') && !hasAssignmentOrCall(trimmed))) {
-        return false;
-    }
-    
-    if (trimmed.startsWith('function ') ||
-        trimmed.startsWith('if ') ||
-        trimmed.startsWith('else') ||
-        trimmed.startsWith('for ') ||
-        trimmed.startsWith('while ') ||
-        trimmed.startsWith('switch ') ||
-        trimmed.startsWith('try') ||
-        trimmed.startsWith('catch') ||
-        trimmed.startsWith('finally') ||
-        trimmed.startsWith('import ') ||
-        trimmed.startsWith('export ') ||
-        trimmed.match(/^}\s*else/)) {
-        return false;
-    }
-
-    return (
-        trimmed.includes('=') || 
-        trimmed.includes('console.log') ||
-        trimmed.includes('return ') ||
-        trimmed.startsWith('const ') ||
-        trimmed.startsWith('let ') ||
-        trimmed.startsWith('var ') ||
-        /^[a-zA-Z_$][a-zA-Z0-9_$.]*\s*\(/.test(trimmed) ||
-        Boolean(trimmed.match(/^\w+\s*\+\+/)) ||
-        Boolean(trimmed.match(/^\w+\s*--/)) ||
-        Boolean(trimmed.match(/^\w+\s*[+\-*/]=/))
-    );
-}
-
-function hasAssignmentOrCall(line: string): boolean {
-    const trimmedLine = line.trim();
-    return trimmedLine.includes('=') || 
-           trimmedLine.includes('console.log') || 
-           trimmedLine.includes('return ') ||
-           /^[a-zA-Z_$][a-zA-Z0-9_$.]*\s*\(/.test(trimmedLine);
-}

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "NodeNext",
-    "rootDir": "./src",
-    "outDir": "./dist",
-    "esModuleInterop": true,
-    "strict": true,
-    "skipLibCheck": true,
-    "resolveJsonModule": true
-  },
-  "include": [
-    "src/**/*"
-  ]
-}