@tng-sh/js 0.0.1

package/LICENSE.md

@@ -0,0 +1,32 @@
+# Commercial License
+
+Copyright (c) 2026 Binary Dreams LLC. All rights reserved.
+
+## License Grant
+
+This software is available under a commercial license. You may use this software if you have obtained a valid license from the copyright holder.
+
+## Restrictions
+
+Without a valid commercial license, you may NOT:
+- Use this software in any commercial or production environment
+- Fork, copy, modify, or create derivative works
+- Distribute, redistribute, sublicense, or sell copies
+- Reverse engineer or decompile the software
+- Remove or alter any copyright notices
+
+## Commercial Use
+
+To obtain a commercial license for production use, contact: [raluca@tng.sh]
+
+## Evaluation Use
+
+You may evaluate this software for a period of 30 days for non-commercial purposes only.
+
+## Termination
+
+Any unauthorized use will result in immediate termination of rights and may result in legal action.
+
+## Disclaimer
+
+THIS SOFTWARE IS PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED.

package/bin/tng.js

@@ -0,0 +1,289 @@
+#!/usr/bin/env node
+
+const { program } = require('commander');
+const chalk = require('chalk');
+const fs = require('fs');
+const path = require('path');
+const { loadConfig } = require('../lib/config');
+const { saveTestFile } = require('../lib/saveFile');
+const { ping, getUserStats } = require('../index');
+
+program
+    .name('tng')
+    .description('TNG - Automated Test Generation for JavaScript')
+    .version('0.0.1');
+
+/**
+ * @command init
+ * Initialize TNG configuration - creates tng.config.js
+ */
+program
+    .command('init')
+    .description('Initialize TNG configuration')
+    .action(() => {
+        console.log(chalk.blue.bold('\nTNG Configuration Setup'));
+        const configPath = path.join(process.cwd(), 'tng.config.js');
+
+        if (fs.existsSync(configPath)) {
+            console.log(chalk.yellow('tng.config.js already exists. Keeping existing config.'));
+            return;
+        }
+
+        const content = `/**
+ * TNG Configuration - Project settings for test generation
+ */
+
+module.exports = {
+  // API Configuration
+  API_KEY: "your-api-key-here",
+  API_URL: "https://app.tng.sh/",
+
+  // Framework Detection
+  // Options: express, nextjs, nestjs, generic
+  FRAMEWORK: "express",
+
+  // Testing Configuration
+  // Options: jest, mocha, vitest
+  TEST_FRAMEWORK: "jest",
+
+  // Test Directory
+  TEST_DIRECTORY: "tests"
+};
+`;
+        fs.writeFileSync(configPath, content);
+        console.log(chalk.green(`✓ Created tng.config.js`));
+    });
+
+/**
+ * @command ping
+ * Verify API connectivity
+ */
+program
+    .command('ping')
+    .description('Verify API connectivity')
+    .action(() => {
+        const config = loadConfig();
+        if (!config.API_KEY) {
+            console.log(chalk.red('No API key configured. Run: tng init'));
+            return;
+        }
+
+        console.log(chalk.blue('Pinging TNG API...'));
+        try {
+            const result = ping(config.API_URL, config.API_KEY);
+            console.log(chalk.green(`✓ API Response: ${result}`));
+        } catch (error) {
+            console.log(chalk.red(`✗ Ping failed: ${error.message}`));
+        }
+    });
+
+/**
+ * @command stats
+ * Show user statistics
+ */
+program
+    .command('stats')
+    .description('Show user statistics')
+    .action(() => {
+        const config = loadConfig();
+        if (!config.API_KEY) {
+            console.log(chalk.red('No API key configured. Run: tng init'));
+            return;
+        }
+
+        console.log(chalk.blue('Fetching user stats...'));
+        try {
+            const statsJson = getUserStats(config.API_URL, config.API_KEY);
+            const stats = JSON.parse(statsJson);
+
+            console.log(chalk.bold('\n--- TNG User Statistics ---'));
+            console.log(`User ID:    ${chalk.cyan(stats.user_id || 'N/A')}`);
+            console.log(`Email:      ${chalk.cyan(stats.email || 'N/A')}`);
+            console.log(`Plan:       ${chalk.cyan(stats.plan || 'Free')}`);
+            console.log(`Generations: ${chalk.green(stats.generations_count || 0)} / ${stats.generations_limit || '∞'}`);
+            console.log(`Status:     ${stats.active ? chalk.green('Active') : chalk.red('Inactive')}`);
+            console.log('---------------------------\n');
+        } catch (error) {
+            console.log(chalk.red(`✗ Failed to fetch stats: ${error.message}`));
+        }
+    });
+
+const GenerateTestsUI = require('../lib/generateTestsUi');
+
+function launchInteractive() {
+    const ui = new GenerateTestsUI();
+    ui.show().catch(err => {
+        console.error(chalk.red('\nInteractive UI Error:'), err.message);
+        process.exit(1);
+    });
+}
+
+program
+    .command('i')
+    .alias('interactive')
+    .description('Launch interactive UI')
+    .action(() => {
+        launchInteractive();
+    });
+
+/**
+ * Main command handler (handles -f and -m)
+ */
+program
+    .option('-m, --method <name>', 'Method name to test')
+    .option('-f, --file <path>', 'JavaScript file path')
+    .option('-t, --type <type>', 'Component type (react_component, express_handler, etc)')
+    .option('-a, --audit', 'Run audit mode instead of test generation')
+    .option('--json', 'Output results as JSON events (machine-readable)')
+    .option('--outline', 'Output file outline (methods/classes) in JSON format')
+    .action(async (options) => {
+        if (options.file && options.outline) {
+            printOutline(options.file);
+        } else if (options.method && options.file) {
+            generateTest(options.file, options.method, options.type, options.audit, options.json);
+        } else if (options.file && !options.method) {
+            console.log(chalk.yellow('Specify a method with -m, use --outline to see methods, or run "tng i" for full selection.'));
+        } else if (!options.file && !options.method && process.argv.length <= 2) {
+            launchInteractive();
+        }
+    });
+
+/**
+ * Output file outline (methods)
+ */
+function printOutline(filePath) {
+    const absolutePath = path.resolve(filePath);
+    if (!fs.existsSync(absolutePath)) {
+        console.error(chalk.red(`File not found: ${filePath}`));
+        process.exit(1);
+    }
+
+    const { getFileOutline } = require('../index');
+    try {
+        const outlineJson = getFileOutline(absolutePath);
+        console.log(outlineJson);
+    } catch (error) {
+        console.error(chalk.red(`Error getting outline: ${error.message}`));
+        process.exit(1);
+    }
+}
+
+/**
+ * Logic to generate test or run audit (delegates to native binary)
+ */
+async function generateTest(filePath, methodName, testType, auditMode = false, jsonMode = false) {
+    const config = loadConfig();
+
+    // Initialize JSON session if requested
+    const jsonSession = jsonMode ? new (require('../lib/jsonSession').JsonSession)() : null;
+
+    if (jsonSession) {
+        jsonSession.start();
+    }
+
+    if (!config.API_KEY) {
+        const message = 'No API key configured. Run: tng init';
+        if (jsonSession) {
+            jsonSession.showConfigError('API_KEY');
+            jsonSession.stop();
+        } else {
+            console.log(chalk.red(message));
+        }
+        process.exit(1);
+    }
+
+    const absolutePath = path.resolve(filePath);
+    if (!fs.existsSync(absolutePath)) {
+        const message = `File not found: ${filePath}`;
+        if (jsonSession) {
+            jsonSession.displayError(message);
+            jsonSession.stop();
+        } else {
+            console.log(chalk.red(message));
+        }
+        process.exit(1);
+    }
+
+    const { submitAndPoll } = require('../index');
+
+    const action = auditMode ? 'Auditing' : 'Generating test for';
+    const startMessage = `🔍 ${action} ${methodName} in ${filePath}...`;
+
+    if (jsonSession) {
+        jsonSession.displayInfo(startMessage);
+        if (testType) {
+            jsonSession.displayInfo(`Type hint: ${testType}`);
+        }
+    } else {
+        console.log(chalk.blue(startMessage));
+        if (testType) {
+            console.log(chalk.cyan(`ℹ️  Type hint: ${testType}`));
+        }
+    }
+
+    try {
+        const resultJson = submitAndPoll(
+            absolutePath,
+            methodName,
+            null, // class_name
+            testType || null,
+            auditMode, // audit_mode
+            JSON.stringify(config),
+            (msg, percent) => {
+                if (jsonSession) {
+                    // Emit progress events in JSON mode
+                    const reporter = new (require('../lib/jsonSession').JsonProgressReporter)();
+                    reporter.update(msg, percent);
+                } else {
+                    // Simple console progress for CLI mode
+                    if (percent % 10 === 0 || percent === 100) {
+                        console.log(chalk.cyan(`[${percent}%] ${msg}`));
+                    }
+                }
+            }
+        );
+
+        if (auditMode) {
+            // In audit mode, display the results
+            const result = JSON.parse(resultJson);
+            if (jsonSession) {
+                jsonSession.showAuditResults(result);
+                jsonSession.stop();
+            } else {
+                console.log(chalk.green('\n✓ Audit complete!\n'));
+                console.log(JSON.stringify(result, null, 2));
+            }
+        } else {
+            // In test generation mode, save the file
+            const saved = await saveTestFile(resultJson);
+
+            if (jsonSession) {
+                if (saved) {
+                    jsonSession.emitEvent('test_saved', {
+                        file_path: saved.file_path,
+                        message: `Test saved to: ${saved.file_path}`
+                    });
+                } else {
+                    jsonSession.displayError('Failed to save test file');
+                }
+                jsonSession.stop();
+            } else {
+                if (saved) {
+                    console.log(chalk.green(`✓ Test saved to: ${saved.file_path}`));
+                } else {
+                    console.log(chalk.yellow('Failed to save test file'));
+                }
+            }
+        }
+    } catch (error) {
+        if (jsonSession) {
+            jsonSession.displayError(error.message);
+            jsonSession.stop();
+        } else {
+            console.log(chalk.red(`Error: ${error.message}`));
+        }
+        process.exit(1);
+    }
+}
+
+program.parse(process.argv);

package/index.d.ts

@@ -0,0 +1,12 @@
+/* tslint:disable */
+/* eslint-disable */
+
+/* auto-generated by NAPI-RS */
+
+export declare function getFileOutline(filePath: string): string
+export declare function getProjectMetadata(projectRoot: string): string
+export declare function findCallSites(projectRoot: string, methodName: string): string
+export declare function ping(baseUrl: string, apiKey?: string | undefined | null): string
+export declare function submitJob(baseUrl: string, apiKey: string, payloadJson: string): number
+export declare function getUserStats(baseUrl: string, apiKey: string): string
+export declare function submitAndPoll(filePath: string, methodName: string, className: string | undefined | null, testType: string | undefined | null, auditMode: boolean, configJson: string, callback: (...args: any[]) => any): string

package/index.js

@@ -0,0 +1,321 @@
+/* tslint:disable */
+/* eslint-disable */
+/* prettier-ignore */
+
+/* auto-generated by NAPI-RS */
+
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
+
+const { platform, arch } = process
+
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
+
+function isMusl() {
+  // For Node 10
+  if (!process.report || typeof process.report.getReport !== 'function') {
+    try {
+      const lddPath = require('child_process').execSync('which ldd').toString().trim()
+      return readFileSync(lddPath, 'utf8').includes('musl')
+    } catch (e) {
+      return true
+    }
+  } else {
+    const { glibcVersionRuntime } = process.report.getReport().header
+    return !glibcVersionRuntime
+  }
+}
+
+switch (platform) {
+  case 'android':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, 'index.android-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./index.android-arm64.node')
+          } else {
+            nativeBinding = require('@tng-sh/js-android-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, 'index.android-arm-eabi.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./index.android-arm-eabi.node')
+          } else {
+            nativeBinding = require('@tng-sh/js-android-arm-eabi')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Android ${arch}`)
+    }
+    break
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(
+          join(__dirname, 'index.win32-x64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./index.win32-x64-msvc.node')
+          } else {
+            nativeBinding = require('@tng-sh/js-win32-x64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(
+          join(__dirname, 'index.win32-ia32-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./index.win32-ia32-msvc.node')
+          } else {
+            nativeBinding = require('@tng-sh/js-win32-ia32-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'index.win32-arm64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./index.win32-arm64-msvc.node')
+          } else {
+            nativeBinding = require('@tng-sh/js-win32-arm64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Windows: ${arch}`)
+    }
+    break
+  case 'darwin':
+    localFileExisted = existsSync(join(__dirname, 'index.darwin-universal.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./index.darwin-universal.node')
+      } else {
+        nativeBinding = require('@tng-sh/js-darwin-universal')
+      }
+      break
+    } catch {}
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, 'index.darwin-x64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./index.darwin-x64.node')
+          } else {
+            nativeBinding = require('@tng-sh/js-darwin-x64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, 'index.darwin-arm64.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./index.darwin-arm64.node')
+          } else {
+            nativeBinding = require('@tng-sh/js-darwin-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on macOS: ${arch}`)
+    }
+    break
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(`Unsupported architecture on FreeBSD: ${arch}`)
+    }
+    localFileExisted = existsSync(join(__dirname, 'index.freebsd-x64.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./index.freebsd-x64.node')
+      } else {
+        nativeBinding = require('@tng-sh/js-freebsd-x64')
+      }
+    } catch (e) {
+      loadError = e
+    }
+    break
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'index.linux-x64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./index.linux-x64-musl.node')
+            } else {
+              nativeBinding = require('@tng-sh/js-linux-x64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'index.linux-x64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./index.linux-x64-gnu.node')
+            } else {
+              nativeBinding = require('@tng-sh/js-linux-x64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'index.linux-arm64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./index.linux-arm64-musl.node')
+            } else {
+              nativeBinding = require('@tng-sh/js-linux-arm64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'index.linux-arm64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./index.linux-arm64-gnu.node')
+            } else {
+              nativeBinding = require('@tng-sh/js-linux-arm64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'index.linux-arm-musleabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./index.linux-arm-musleabihf.node')
+            } else {
+              nativeBinding = require('@tng-sh/js-linux-arm-musleabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'index.linux-arm-gnueabihf.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./index.linux-arm-gnueabihf.node')
+            } else {
+              nativeBinding = require('@tng-sh/js-linux-arm-gnueabihf')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'riscv64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, 'index.linux-riscv64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./index.linux-riscv64-musl.node')
+            } else {
+              nativeBinding = require('@tng-sh/js-linux-riscv64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, 'index.linux-riscv64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./index.linux-riscv64-gnu.node')
+            } else {
+              nativeBinding = require('@tng-sh/js-linux-riscv64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 's390x':
+        localFileExisted = existsSync(
+          join(__dirname, 'index.linux-s390x-gnu.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./index.linux-s390x-gnu.node')
+          } else {
+            nativeBinding = require('@tng-sh/js-linux-s390x-gnu')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(`Unsupported architecture on Linux: ${arch}`)
+    }
+    break
+  default:
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
+}
+
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError
+  }
+  throw new Error(`Failed to load native binding`)
+}
+
+const { getFileOutline, getProjectMetadata, findCallSites, ping, submitJob, getUserStats, submitAndPoll } = nativeBinding
+
+module.exports.getFileOutline = getFileOutline
+module.exports.getProjectMetadata = getProjectMetadata
+module.exports.findCallSites = findCallSites
+module.exports.ping = ping
+module.exports.submitJob = submitJob
+module.exports.getUserStats = getUserStats
+module.exports.submitAndPoll = submitAndPoll

package/lib/config.js

@@ -0,0 +1,31 @@
+const path = require('path');
+const fs = require('fs');
+
+const loadConfig = () => {
+    const configFile = path.join(process.cwd(), 'tng.config.js');
+
+    if (!fs.existsSync(configFile)) {
+        return {};
+    }
+
+    try {
+        // Clear cache to allow reloading config in same process if needed (rare for CLI but good practice)
+        delete require.cache[require.resolve(configFile)];
+        const config = require(configFile);
+
+        // Filter for uppercase keys to match Python's convention,
+        // but fallback to the whole object if none are uppercase.
+        const filtered = {};
+        for (const [key, value] of Object.entries(config)) {
+            if (key === key.toUpperCase()) {
+                filtered[key] = value;
+            }
+        }
+
+        return Object.keys(filtered).length > 0 ? filtered : config;
+    } catch (error) {
+        return {};
+    }
+};
+
+module.exports = { loadConfig };