typenative 0.0.19 → 0.0.21

package/bin/index.js

@@ -1,151 +1,123 @@
-#!/usr/bin/env node
-import inquirer from 'inquirer';
-import fs from 'fs-extra';
+// Core compiler logic — kept free of Node-only dependencies (inquirer, execa,
+// fs-extra) so this module transpiles with TypeNative itself.
+// Node-only interactive prompting lives in src/cli.ts; the self-hosted entry
+// point is src/main.ts.
 import path from 'node:path';
-import { execa } from 'execa';
+import * as fs from 'node:fs';
+import { platform } from 'node:os';
+// TypeNative maps node:child_process to a synchronous Go API whose shape differs
+// from Node's; under Node these functions are never called (the CLI wrapper does
+// not reach them), so they're accessed through `any` casts for type-checking.
+import * as childProcess from 'node:child_process';
 import { transpileToNative } from './transpiler.js';
-import { fileURLToPath } from 'node:url';
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-(async function main() {
-    const scriptMode = process.argv.findIndex((a) => a === '--script') > -1;
-    const newCommand = process.argv.findIndex((a) => a === '--new') > -1;
-    const sourceIndex = process.argv.findIndex((a) => a === '--source');
-    const source = sourceIndex > -1 ? process.argv[sourceIndex + 1] : null;
-    const outputIndex = process.argv.findIndex((a) => a === '--output');
-    const output = outputIndex > -1 ? process.argv[outputIndex + 1] : null;
-    const answers = await inquirer.prompt([
-        {
-            type: 'input',
-            name: 'projectName',
-            message: 'Enter Project Name:',
-            when: newCommand,
-            validate: (input) => input.trim() !== ''
-        },
-        {
-            type: 'confirm',
-            name: 'installDependencies',
-            message: 'Do you want to install dependencies?',
-            when: newCommand
-        },
-        {
-            type: 'input',
-            name: 'path',
-            message: 'Enter Path to typescript main file:',
-            when: !newCommand && !scriptMode && !source,
-            validate: (input) => input.trim() !== ''
-        },
-        {
-            type: 'input',
-            name: 'output',
-            message: 'Enter Output Path:',
-            when: !newCommand && !scriptMode && !output,
-            validate: (input) => input.trim() !== ''
-        },
-        {
-            type: 'editor',
-            name: 'tsCode',
-            message: 'Write your typescript code here:',
-            when: !newCommand && scriptMode && !source,
-            default: `console.log('Hello, World!');`
-        }
-    ]);
-    if (newCommand) {
-        const projectName = answers.projectName.trim();
-        await fs.ensureDir(projectName);
-        await fs.writeFile(path.join(projectName, 'main.ts'), `// Write your TypeScript code here\nconsole.log('Hello, World!');\n`, { encoding: 'utf-8' });
-        await fs.writeFile(path.join(projectName, 'tsconfig.json'), getTsConfig(), {
-            encoding: 'utf-8'
-        });
-        await fs.writeFile(path.join(projectName, 'package.json'), getPackageJson(projectName), {
-            encoding: 'utf-8'
-        });
-        await fs.writeFile(path.join(projectName, '.gitignore'), getGitIgnore(), {
-            encoding: 'utf-8'
-        });
-        await fs.writeFile(path.join(projectName, 'README.md'), getReadMe(projectName), {
-            encoding: 'utf-8'
-        });
-        console.log(`Project "${projectName}" created successfully!`);
-        if (answers.installDependencies) {
-            console.log('Installing dependencies...');
-            await execa('npm', ['install'], { cwd: projectName, stdio: 'inherit' });
-            console.log('Dependencies installed successfully!');
+// Run a command and capture its output. Uses Node's spawnSync under Node and a
+// Go helper (os/exec) once transpiled — both synchronous, same result shape.
+export function runCommand(name, args) {
+    const result = childProcess.spawnSync(name, args, { encoding: 'utf-8' });
+    return { stdout: result.stdout, stderr: result.stderr, status: result.status };
+}
+// Run a command with the parent's stdio, returns the exit code.
+export function runInherit(name, args = []) {
+    const result = childProcess.spawnSync(name, args, { stdio: 'inherit' });
+    return result.status;
+}
+export function createProject(projectName, installDependencies) {
+    fs.mkdirSync(projectName, { recursive: true });
+    fs.writeFileSync(path.join(projectName, 'main.ts'), `// Write your TypeScript code here\nconsole.log('Hello, World!');\n`);
+    fs.writeFileSync(path.join(projectName, 'tsconfig.json'), getTsConfig());
+    fs.writeFileSync(path.join(projectName, 'package.json'), getPackageJson(projectName));
+    fs.writeFileSync(path.join(projectName, '.gitignore'), getGitIgnore());
+    fs.writeFileSync(path.join(projectName, 'README.md'), getReadMe(projectName));
+    console.log(`Project "${projectName}" created successfully!`);
+    if (installDependencies) {
+        console.log('Installing dependencies...');
+        // npm --prefix avoids needing cwd support in the subprocess binding
+        const result = runCommand('npm', ['install', '--prefix', projectName]);
+        if (result.stdout)
+            console.log(result.stdout.trim());
+        if (result.status !== 0) {
+            if (result.stderr)
+                console.error(result.stderr.trim());
+            process.exit(result.status);
         }
-        return;
+        console.log('Dependencies installed successfully!');
     }
-    const sourcePath = answers.tsCode ? null : (source ?? answers.path ?? null);
-    const tsCode = answers.tsCode
-        ? answers.tsCode
-        : await fs.readFile(sourcePath, { encoding: 'utf-8' });
+}
+export function run(opts) {
+    const sourcePath = opts.tsCode ? null : opts.source;
+    const tsCode = opts.tsCode ? opts.tsCode : fs.readFileSync(sourcePath, 'utf-8');
     const sourceDir = sourcePath ? path.dirname(path.resolve(sourcePath)) : null;
-    const transpileResult = transpileToNative(tsCode, sourceDir
-        ? {
-            readFile: (specifier, fromDir) => {
-                const baseDir = fromDir ?? sourceDir;
-                // Relative or absolute path → resolve from baseDir
-                if (specifier.startsWith('.') || specifier.startsWith('/')) {
-                    for (const candidate of [specifier + '.ts', specifier]) {
-                        try {
-                            const fullPath = path.resolve(baseDir, candidate);
-                            return {
-                                content: fs.readFileSync(fullPath, 'utf-8'),
-                                dir: path.dirname(fullPath)
-                            };
-                        }
-                        catch {
-                            /* not found */
-                        }
+    const transpileOptions = { parse: opts.parse };
+    if (sourceDir) {
+        transpileOptions.readFile = (specifier, fromDir) => {
+            const baseDir = fromDir ?? sourceDir;
+            // Relative or absolute path → resolve from baseDir
+            if (specifier.startsWith('.') || specifier.startsWith('/')) {
+                // ES convention: ./x.js may refer to x.ts
+                const tsSpecifier = specifier.endsWith('.js')
+                    ? specifier.replace(/\.js$/, '.ts')
+                    : specifier;
+                for (const candidate of [tsSpecifier + '.ts', tsSpecifier, specifier]) {
+                    try {
+                        const fullPath = path.resolve(baseDir, candidate);
+                        return {
+                            content: fs.readFileSync(fullPath, 'utf-8'),
+                            dir: path.dirname(fullPath)
+                        };
+                    }
+                    catch {
+                        /* not found */
                     }
-                    return null;
-                }
-                // npm package — walk up from baseDir looking for node_modules/<name>
-                const resolved = resolveNpmPackage(baseDir, specifier);
-                if (!resolved)
-                    return null;
-                let { content, dir } = resolved;
-                // Normalize CommonJS to ES module syntax
-                if (!content.includes('export ') && (content.includes('module.exports') || content.includes('exports.'))) {
-                    content = normalizeCjsContent(content);
                 }
-                // Inject types from a local ambient .d.ts if available
-                const typed = tryInjectDtsTypes(content, specifier, sourceDir);
-                if (typed)
-                    content = typed;
-                return { content, dir };
+                return null;
             }
-        }
-        : undefined);
-    const exeName = process.platform === 'win32' ? 'native.exe' : 'native';
+            // npm package — walk up from baseDir looking for node_modules/<name>
+            const resolved = resolveNpmPackage(baseDir, specifier);
+            if (!resolved)
+                return null;
+            let { content, dir } = resolved;
+            // Normalize CommonJS to ES module syntax
+            if (!content.includes('export ') &&
+                (content.includes('module.exports') || content.includes('exports.'))) {
+                content = normalizeCjsContent(content);
+            }
+            // Inject types from a local ambient .d.ts if available
+            const typed = tryInjectDtsTypes(content, specifier, sourceDir);
+            if (typed)
+                content = typed;
+            return { content, dir };
+        };
+    }
+    const transpileResult = transpileToNative(tsCode, transpileOptions);
+    const exeName = platform() === 'win32' ? 'native.exe' : 'native';
     const exePath = `dist/${exeName}`;
-    await fs.ensureDir('dist');
+    fs.mkdirSync('dist', { recursive: true });
     // Clean up stale Go files from previous runs before writing new ones
-    for (const existing of await fs.readdir('dist')) {
+    for (const existing of fs.readdirSync('dist')) {
         if (existing.endsWith('.go'))
-            await fs.remove(`dist/${existing}`);
+            fs.rmSync(`dist/${existing}`);
     }
-    await fs.writeFile('dist/code.go', transpileResult.main, { encoding: 'utf-8' });
+    fs.writeFileSync('dist/code.go', transpileResult.main);
     const goFiles = ['dist/code.go'];
     for (const [filename, content] of transpileResult.files) {
-        await fs.writeFile(`dist/${filename}`, content, { encoding: 'utf-8' });
+        fs.writeFileSync(`dist/${filename}`, content);
         goFiles.push(`dist/${filename}`);
     }
-    await execa('go', ['build', '-o', exePath, ...goFiles], {
-        stdio: 'inherit'
-    });
-    // await fs.remove('dist/code.go');
-    if (scriptMode) {
-        await execa(exePath, {
-            stdio: 'inherit'
-        });
-        //await fs.remove(exePath);
+    const buildResult = runCommand('go', ['build', '-o', exePath, ...goFiles]);
+    if (buildResult.status !== 0) {
+        console.error('go build failed:');
+        if (buildResult.stderr)
+            console.error(buildResult.stderr.trim());
+        process.exit(1);
     }
-    else if (output || answers.output) {
-        await fs.copy(exePath, output ?? answers.output, { overwrite: true });
-        //await fs.remove(exePath);
-        console.log(`Created native executable at: ${output ?? answers.output}`);
+    if (opts.scriptMode) {
+        process.exit(runInherit(exePath));
     }
-})();
+    else if (opts.output) {
+        fs.copyFileSync(exePath, opts.output);
+        console.log(`Created native executable at: ${opts.output}`);
+    }
+}
 function normalizeCjsContent(code) {
     code = code.replace(/['"]use strict['"];?\n?/g, '');
     code = code.replace(/(?:module\.exports|exports)\.(\w+)\s*=\s*function\s*\w*\s*\(/g, 'export function $1(');
@@ -237,7 +209,7 @@ function resolveNpmPackage(fromDir, packageName) {
     return null;
 }
 function getPackageJson(projectName) {
-    const exeName = process.platform === 'win32' ? `${projectName}.exe` : projectName;
+    const exeName = platform() === 'win32' ? `${projectName}.exe` : projectName;
     const pckg = {
         name: projectName,
         version: '1.0.0',
@@ -274,7 +246,7 @@ bin/
 `;
 }
 function getReadMe(projectName) {
-    const exeName = process.platform === 'win32' ? `${projectName}.exe` : projectName;
+    const exeName = platform() === 'win32' ? `${projectName}.exe` : projectName;
     return `# ${projectName}
 
 This project was created using TypeNative, a tool to transpile TypeScript code to native Go code.

package/bin/main.js

@@ -0,0 +1,31 @@
+// Self-hosting entry point: this file is what TypeNative compiles to produce
+// the native compiler binary. Interactive prompts use the transpilable
+// prompt module (sync stdin) instead of inquirer.
+import { run, createProject } from './index.js';
+import { ask, askMultiline, confirm } from './prompt.js';
+import { parseAstJsonNative } from './parse-native.js';
+(function main() {
+    const scriptMode = process.argv.findIndex((a) => a === '--script') > -1;
+    const newCommand = process.argv.findIndex((a) => a === '--new') > -1;
+    const sourceIndex = process.argv.findIndex((a) => a === '--source');
+    let source = sourceIndex > -1 ? process.argv[sourceIndex + 1] : null;
+    const outputIndex = process.argv.findIndex((a) => a === '--output');
+    let output = outputIndex > -1 ? process.argv[outputIndex + 1] : null;
+    if (newCommand) {
+        const projectName = ask('Enter Project Name:');
+        const installDependencies = confirm('Do you want to install dependencies?');
+        createProject(projectName, installDependencies);
+        return;
+    }
+    let tsCode = null;
+    if (!newCommand && !scriptMode && !source) {
+        source = ask('Enter Path to typescript main file:');
+    }
+    if (!newCommand && !scriptMode && !output) {
+        output = ask('Enter Output Path:');
+    }
+    if (!newCommand && scriptMode && !source) {
+        tsCode = askMultiline('Write your typescript code here:');
+    }
+    run({ source, output, scriptMode, tsCode, parse: parseAstJsonNative });
+})();

package/bin/parse-native.js

@@ -0,0 +1,37 @@
+// Self-hosted parser: spawns the tsparser Go tool (tsparser/main.go) to parse
+// TypeScript into the normalized JSON AST. Fully transpilable — used by the
+// native compiler binary instead of the typescript npm package.
+import * as path from 'node:path';
+import * as fs from 'node:fs';
+import * as childProcess from 'node:child_process';
+export function parseAstJsonNative(code) {
+    const exe = findTsparser();
+    const result = childProcess.spawnSync(exe, [], { input: code, encoding: 'utf-8' });
+    if (result.status !== 0) {
+        throw new Error('tsparser failed: ' + result.stderr);
+    }
+    return JSON.parse(result.stdout);
+}
+// Locates the tsparser binary: TYPENATIVE_TSPARSER env var, next to this
+// executable, or in a sibling tsparser/ directory (dev checkout layout).
+function findTsparser() {
+    const exeName = platformIsWindows() ? 'tsparser.exe' : 'tsparser';
+    const envPath = process.env.TYPENATIVE_TSPARSER;
+    if (envPath && fs.existsSync(envPath))
+        return envPath;
+    const thisDir = path.dirname(path.resolve(process.argv[0]));
+    const candidates = [
+        path.join(thisDir, exeName),
+        path.join(thisDir, 'tsparser', exeName),
+        path.join(thisDir, '..', 'tsparser', exeName),
+        path.join(thisDir, '..', '..', 'tsparser', exeName)
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    throw new Error('tsparser binary not found; set TYPENATIVE_TSPARSER');
+}
+function platformIsWindows() {
+    return process.platform === 'win32';
+}

package/bin/parse-node.js

@@ -0,0 +1,110 @@
+// Node-side AST adapter: converts a `typescript` npm package AST into the same
+// normalized JSON shape that the `tsparser` Go tool emits
+// (tsparser/main.go). The transpiler consumes this shape, so dev-CLI output and
+// self-hosted (Go parser) output are field-compatible.
+//
+// Node-only module: imports the `typescript` package directly and is injected
+// into the transpiler by the Node CLI wrapper (src/cli.ts). The self-hosted
+// binary uses src/parse-native.ts instead.
+import ts from 'typescript';
+// Internal ts.Node bookkeeping properties that must not leak into the JSON
+const SKIP_PROPS = new Set([
+    'pos',
+    'end',
+    'flags',
+    'modifierFlagsCache',
+    'transformFlags',
+    'parent',
+    'original',
+    'symbol',
+    'id',
+    'jsDoc',
+    'flowNode',
+    'contextFlags',
+    'parserContextFlags',
+    'excludeFlags',
+    'modifierFlags',
+    'flowId',
+    'symbolCount',
+    'identifierCount',
+    'nodeArrayCache',
+    'parsedByParser',
+    'autoGenerateKind',
+    'autoGenerateId',
+    'emitNode',
+    'localSymbol',
+    // 'text'/'escapedText' are only emitted for token-like kinds (TEXT_KINDS);
+    // SourceFile.text would otherwise leak the whole source into the AST
+    'text',
+    'escapedText',
+    'endOfFileToken',
+    'externalModuleIndicator',
+    'commonJsModuleIndicator',
+    'localJsxNamespace',
+    'localJsxFactory',
+    'localJsxFragmentFactory'
+]);
+const TEXT_KINDS = new Set([
+    ts.SyntaxKind.Identifier,
+    ts.SyntaxKind.PrivateIdentifier,
+    ts.SyntaxKind.StringLiteral,
+    ts.SyntaxKind.NumericLiteral,
+    ts.SyntaxKind.BigIntLiteral,
+    ts.SyntaxKind.NoSubstitutionTemplateLiteral,
+    ts.SyntaxKind.RegularExpressionLiteral,
+    ts.SyntaxKind.TemplateHead,
+    ts.SyntaxKind.TemplateMiddle,
+    ts.SyntaxKind.TemplateTail,
+    ts.SyntaxKind.JsxText
+]);
+// Reverse enum map preferring canonical names over aliases
+// (ts.SyntaxKind[8] is "FirstLiteralToken", the alias of NumericLiteral)
+const KIND_NAMES = (() => {
+    const names = {};
+    for (const key of Object.keys(ts.SyntaxKind)) {
+        const val = ts.SyntaxKind[key];
+        if (typeof val === 'number' && names[val] === undefined)
+            names[val] = key;
+    }
+    return names;
+})();
+function isNode(v) {
+    return typeof v === 'object' && v !== null && typeof v.kind === 'number' && typeof v.pos === 'number';
+}
+function convertNode(node) {
+    const obj = { kind: KIND_NAMES[node.kind] ?? String(node.kind) };
+    if (TEXT_KINDS.has(node.kind)) {
+        obj.text = node.text ?? node.escapedText;
+    }
+    for (const key of Object.keys(node)) {
+        if (SKIP_PROPS.has(key))
+            continue;
+        const v = node[key];
+        if (typeof v === 'function')
+            continue;
+        if (v === null || v === undefined)
+            continue;
+        if (isNode(v)) {
+            obj[key] = convertNode(v);
+        }
+        else if (Array.isArray(v)) {
+            const arr = v.filter((e) => isNode(e)).map((e) => convertNode(e));
+            if (arr.length > 0)
+                obj[key] = arr;
+        }
+        else if (typeof v === 'number' && key === 'operator') {
+            // unary operator: emit the kind name (matches the Go producer)
+            obj[key] = KIND_NAMES[v] ?? String(v);
+        }
+        else if (typeof v === 'string' || typeof v === 'number' || typeof v === 'boolean') {
+            if (key !== 'kind')
+                obj[key] = v;
+        }
+    }
+    return obj;
+}
+// Parse TypeScript source into the normalized JSON AST shape.
+export function parseAstJson(code) {
+    const sourceFile = ts.createSourceFile('main.ts', code, ts.ScriptTarget.ES2020, true, ts.ScriptKind.TS);
+    return convertNode(sourceFile);
+}

package/bin/prompt.js

@@ -0,0 +1,29 @@
+// Interactive prompts for the self-hosted native binary.
+// Implemented exclusively with TypeNative-mapped APIs (node:readline → Go helper)
+// so this module transpiles. Under Node the namespace import of node:readline is
+// valid but `question` is only available once transpiled — the Node CLI wrapper
+// (src/cli.ts) resolves prompts via inquirer instead and never calls these.
+import * as readlineSync from 'node:readline';
+export function ask(message) {
+    let input = readlineSync.question(message + ' ');
+    while (input.trim() === '') {
+        console.log('Please enter a non-empty value.');
+        input = readlineSync.question(message + ' ');
+    }
+    return input.trim();
+}
+export function askMultiline(message) {
+    console.log(message);
+    console.log("(finish with a line containing only 'END')");
+    const lines = [];
+    let line = readlineSync.question('');
+    while (line.trim() !== 'END') {
+        lines.push(line);
+        line = readlineSync.question('');
+    }
+    return lines.join('\n');
+}
+export function confirm(message) {
+    const answer = readlineSync.question(message + ' (y/n): ');
+    return answer.trim().toLowerCase() === 'y';
+}