tsdk-cli 1.0.0

package/bin/tsdk.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+
+const { compileFile, run, requireTs } = require('../index.js');
+const path = require('path');
+const fs = require('fs');
+
+const args = process.argv.slice(2);
+
+if (args.length === 0) {
+    console.log(`
+tsdk-cli - TypeScript Development Kit
+
+Usage:
+  tsdk <file> [args...]       Run a TypeScript file
+  tsdk -e <code>              Evaluate TypeScript code
+  tsdk -v, --version          Show version
+  tsdk -h, --help             Show this help
+
+Examples:
+  tsdk app.ts
+  tsdk server.ts --port 3000
+  tsdk -e "console.log('Hello TypeScript!')"
+    `);
+    process.exit(0);
+}
+
+const version = require('../package.json').version;
+
+if (args[0] === '-v' || args[0] === '--version') {
+    console.log(`tsdk-cli v${version}`);
+    process.exit(0);
+}
+
+if (args[0] === '-h' || args[0] === '--help') {
+    console.log(`
+tsdk-cli - TypeScript Development Kit
+
+Usage:
+  tsdk <file> [args...]       Run a TypeScript file
+  tsdk -e <code>              Evaluate TypeScript code
+  tsdk -v, --version          Show version
+  tsdk -h, --help             Show this help
+
+Examples:
+  tsdk app.ts
+  tsdk server.ts --port 3000
+  tsdk -e "console.log('Hello TypeScript!')"
+    `);
+    process.exit(0);
+}
+
+if (args[0] === '-e') {
+    const code = args[1];
+    if (!code) {
+        console.error('Error: No code provided with -e option');
+        process.exit(1);
+    }
+    
+    try {
+        const { compile } = require('../index.js');
+        const { code: compiled } = compile(code, { loader: 'ts' });
+        eval(compiled);
+        process.exit(0);
+    } catch (error) {
+        console.error(`Error: ${error.message}`);
+        process.exit(1);
+    }
+}
+
+const filePath = args[0];
+const fileArgs = args.slice(1);
+
+const ext = path.extname(filePath).toLowerCase();
+
+if (!ext || (ext !== '.ts' && ext !== '.tsx')) {
+    console.error(`Error: Unsupported file type ${ext}. Only .ts and .tsx files are supported.`);
+    process.exit(1);
+}
+
+const fullPath = path.resolve(filePath);
+
+if (!fs.existsSync(fullPath)) {
+    console.error(`Error: File not found: ${fullPath}`);
+    process.exit(1);
+}
+
+process.argv = [process.argv[0], process.argv[1], ...fileArgs];
+
+try {
+    requireTs(fullPath);
+} catch (error) {
+    console.error(`Error: ${error.message}`);
+    console.error(error.stack);
+    process.exit(1);
+}

package/index.js

@@ -0,0 +1,133 @@
+const { transformSync } = require('esbuild');
+const path = require('path');
+const fs = require('fs');
+
+const defaultOptions = {
+    target: 'es2020',
+    platform: 'node',
+    sourcemap: 'inline',
+    loader: 'ts'
+};
+
+function compile(code, options = {}) {
+    const mergedOptions = { ...defaultOptions, ...options };
+    
+    try {
+        const result = transformSync(code, {
+            target: mergedOptions.target,
+            platform: mergedOptions.platform,
+            sourcemap: mergedOptions.sourcemap,
+            loader: mergedOptions.loader
+        });
+        
+        return {
+            code: result.code,
+            map: result.map
+        };
+    } catch (error) {
+        throw new Error(`Compilation error: ${error.message}`);
+    }
+}
+
+function compileFile(filePath, options = {}) {
+    const fullPath = path.resolve(filePath);
+    
+    if (!fs.existsSync(fullPath)) {
+        throw new Error(`File not found: ${fullPath}`);
+    }
+    
+    const code = fs.readFileSync(fullPath, 'utf8');
+    const ext = path.extname(filePath).toLowerCase();
+    
+    const loader = ext === '.tsx' ? 'tsx' : 'ts';
+    
+    return compile(code, { ...options, loader });
+}
+
+function run(filePath, options = {}) {
+    const { code } = compileFile(filePath, options);
+    
+    const moduleWrapper = `
+        const module = { exports: {} };
+        const require = (path) => {
+            const resolved = require.resolve(path);
+            return require(resolved);
+        };
+        require.resolve = (path) => {
+            return require.resolve(path);
+        };
+        const exports = module.exports;
+        ${code}
+        return module.exports;
+    `;
+    
+    return new Function('require', 'module', 'exports', '__dirname', '__filename', code)(
+        require,
+        { exports: {} },
+        {},
+        path.dirname(path.resolve(filePath)),
+        path.resolve(filePath)
+    );
+}
+
+function requireTs(modulePath) {
+    const ext = path.extname(modulePath);
+    const filePath = ext ? modulePath : `${modulePath}.ts`;
+    const fullPath = path.resolve(filePath);
+    
+    if (!fs.existsSync(fullPath)) {
+        throw new Error(`Module not found: ${fullPath}`);
+    }
+    
+    const { code } = compileFile(fullPath);
+    
+    const module = { exports: {} };
+    const requireFn = (reqPath) => {
+        let resolved = reqPath;
+        if (!path.isAbsolute(reqPath)) {
+            resolved = path.resolve(path.dirname(fullPath), reqPath);
+            if (!fs.existsSync(resolved)) {
+                resolved += '.js';
+            }
+            if (!fs.existsSync(resolved)) {
+                resolved = require.resolve(reqPath);
+            }
+        }
+        if (resolved.endsWith('.ts') || resolved.endsWith('.tsx')) {
+            return requireTs(resolved);
+        }
+        return require(resolved);
+    };
+    
+    requireFn.resolve = (reqPath) => require.resolve(reqPath);
+    
+    const dirname = path.dirname(fullPath);
+    
+    const wrappedCode = code.replace(/export\s+const\s+(\w+)\s*=\s*/g, 'module.exports.$1 = ')
+                             .replace(/export\s+function\s+(\w+)/g, 'module.exports.$1 = function $1')
+                             .replace(/export\s+default\s+/g, 'module.exports = ')
+                             .replace(/export\s+\{\s*([^}]+)\s*\}/g, (match, exports) => {
+                                 return exports.split(',').map(e => {
+                                     const name = e.trim();
+                                     return `module.exports['${name}'] = ${name};`;
+                                 }).join('\n');
+                             });
+    
+    new Function('require', 'module', 'exports', '__dirname', '__filename', wrappedCode)(
+        requireFn,
+        module,
+        module.exports,
+        dirname,
+        fullPath
+    );
+    
+    return module.exports;
+}
+
+module.exports = {
+    compile,
+    compileFile,
+    run,
+    requireTs,
+    defaultOptions
+};

package/package.json

@@ -0,0 +1,23 @@
+{
+    "name": "tsdk-cli",
+    "version": "1.0.0",
+    "description": "TypeScript Development Kit - Run TypeScript directly in Node.js",
+    "main": "index.js",
+    "bin": {
+        "tsdk": "./bin/tsdk.js"
+    },
+    "scripts": {
+        "test": "node test/index.js"
+    },
+    "keywords": ["typescript", "node", "cli", "runtime", "ts-node", "esbuild"],
+    "author": "Vexify",
+    "license": "Apache-2.0",
+    "files": [
+        "index.js",
+        "bin/",
+        "LICENSE"
+    ],
+    "dependencies": {
+        "esbuild": "^0.21.0"
+    }
+}