@tng-sh/js 0.0.1

package/lib/generateTestsUi.js

@@ -0,0 +1,330 @@
+const fs = require('fs');
+const path = require('path');
+const glob = require('fast-glob');
+const chalk = require('chalk');
+const GoUISession = require('./goUiSession');
+const { getFileOutline, submitAndPoll, ping, getUserStats } = require('../index');
+const { loadConfig } = require('./config');
+const { saveTestFile } = require('./saveFile');
+
+class GenerateTestsUI {
+    constructor(cliMode = false) {
+        this.cliMode = cliMode;
+        if (!cliMode) {
+            this.goUiSession = new GoUISession();
+            this.goUiSession.start();
+        }
+    }
+
+    async show() {
+        // Check for API key before showing menu
+        const config = loadConfig();
+        if (!config.API_KEY) {
+            this._showConfigMissing();
+            return 'exit';
+        }
+
+        while (true) {
+            const choice = this.goUiSession.showMenu();
+
+            if (choice === 'generate' || choice === 'tests' || choice === 'select_file') {
+                const result = await this._showFileSelection(false);
+                if (result === 'exit') return 'exit';
+            } else if (choice === 'audit') {
+                const result = await this._showFileSelection(true);
+                if (result === 'exit') return 'exit';
+            } else if (choice === 'stats') {
+                await this._showStats();
+            } else if (choice === 'about') {
+                this.goUiSession.showAbout();
+            } else if (choice === 'ping') {
+                await this._pingApi();
+            } else if (choice === 'exit' || choice === null) {
+                return 'exit';
+            }
+        }
+    }
+
+    _showConfigMissing() {
+        const { spawnSync } = require('child_process');
+        const dataJson = JSON.stringify({
+            missing_items: ["API key"],
+            config_file: "tng.config.js"
+        });
+
+        spawnSync(this.goUiSession._binaryPath, ['config-missing', '--data', dataJson], {
+            stdio: 'inherit'
+        });
+    }
+
+    async _showStats() {
+        const config = loadConfig();
+        if (!config.API_KEY) {
+            console.log(chalk.red('\nNo API key configured. Run: tng init\n'));
+            console.log(chalk.yellow('Or edit tng.config.js and set your API_KEY\n'));
+            return;
+        }
+
+        try {
+            const statsJson = getUserStats(config.API_URL, config.API_KEY);
+            const stats = JSON.parse(statsJson);
+            this.goUiSession.showStats(stats);
+        } catch (e) {
+            console.error(chalk.red(`\nError fetching stats: ${e.message}\n`));
+        }
+    }
+
+    async _pingApi() {
+        const config = loadConfig();
+        if (!config.API_KEY) {
+            console.log(chalk.red('\nNo API key configured. Run: tng init\n'));
+            console.log(chalk.yellow('Or edit tng.config.js and set your API_KEY\n'));
+            return;
+        }
+
+        this.goUiSession.showSpinner('Pinging TNG API...', () => {
+            try {
+                const result = ping(config.API_URL, config.API_KEY);
+                return { success: true, message: `API Response: ${result}` };
+            } catch (e) {
+                return { success: false, message: e.message };
+            }
+        });
+    }
+
+    async _showFileSelection(isAudit = false) {
+        const files = await this._getUserFiles();
+
+        if (files.length === 0) {
+            console.log(chalk.yellow('No JS/TS files found in project.'));
+            return 'back';
+        }
+
+        const cwd = process.cwd();
+        const items = files.map(file => ({
+            name: path.relative(cwd, file),
+            path: path.dirname(file)
+        }));
+
+        const title = isAudit ? 'Select JavaScript File to Audit' : 'Select JavaScript File';
+        const selectedName = this.goUiSession.showListView(title, items);
+
+        if (selectedName === 'back') return 'back';
+        if (!selectedName || selectedName === 'exit') return 'exit';
+
+        const selectedFile = path.resolve(cwd, selectedName);
+        const result = await this._showMethodsForFile(selectedFile, isAudit);
+        if (result === 'main_menu') return 'main_menu';
+        return result;
+    }
+
+    async _showMethodsForFile(filePath, isAudit = false) {
+        let outline;
+        try {
+            const result = getFileOutline(filePath);
+            outline = JSON.parse(result);
+        } catch (e) {
+            console.error(chalk.red(`Error parsing file: ${e.message}`));
+            return this._showFileSelection();
+        }
+
+        const methods = outline.methods || [];
+        if (methods.length === 0) {
+            this.goUiSession.showNoItems('methods');
+            return this._showFileSelection(isAudit);
+        }
+
+        const fileName = path.basename(filePath);
+        const items = methods.map(m => ({
+            name: m.class_name ? `${m.class_name}.${m.name}` : m.name,
+            path: `Function in ${fileName}`,
+            methodData: m
+        }));
+
+        const title = isAudit ? `Select Method to Audit for ${fileName}` : `Select Method for ${fileName}`;
+        const selectedDisplay = this.goUiSession.showListView(title, items);
+
+        if (selectedDisplay === 'back') return this._showFileSelection(isAudit);
+        if (!selectedDisplay) return this._showFileSelection(isAudit);
+
+        const selectedMethod = items.find(i => i.name === selectedDisplay)?.methodData;
+
+        if (selectedMethod) {
+            // New Step: Select Test Type
+            const testType = this.goUiSession.showJsTestMenu();
+            if (testType === 'back') return this._showFileSelection(isAudit);
+
+            // Handle auto-detect (pass null)
+            const finalType = testType === 'auto' ? null : testType;
+
+            const choice = await this._generateTestsForMethod(filePath, selectedMethod, finalType, isAudit);
+
+            if (isAudit) {
+                if (choice === 'main_menu') return 'main_menu';
+                return this._showFileSelection(isAudit);
+            }
+
+            if (choice && choice.file_path && !choice.error) {
+                this._showPostGenerationMenu(choice);
+            }
+        }
+        return this._showFileSelection(isAudit);
+    }
+
+    async _generateTestsForMethod(filePath, method, testType, isAudit = false) {
+        const fileName = path.basename(filePath);
+        const displayName = method.class_name ? `${method.class_name}#${method.name}` : `${fileName}#${method.name}`;
+        const actionName = isAudit ? 'Auditing' : 'Generating test for';
+
+        const progressHandler = (progress) => {
+            progress.update('Preparing request...');
+
+            try {
+                const config = loadConfig();
+                if (!config.API_KEY) {
+                    progress.error('No API key configured. Run: tng init');
+                    return { error: 'No API key' };
+                }
+
+                const agentMap = {
+                    'context_agent_status': { label: 'Context Builder', step: 1 },
+                    'style_agent_status': { label: 'Style Analyzer', step: 2 },
+                    'logical_issue_status': { label: 'Logic Analyzer', step: 3 },
+                    'behavior_expert_status': { label: 'Logic Generator', step: 4 },
+                    'context_insights_status': { label: 'Context Insights', step: 5 }
+                };
+
+                for (const [key, config] of Object.entries(agentMap)) {
+                    progress.update(`${config.label}: Pending...`, { step_increment: true });
+                }
+
+                // Pass a callback to the native Rust submitAndPoll
+                const resultJson = submitAndPoll(
+                    filePath,
+                    method.name,
+                    method.class_name || null,
+                    testType || null,
+                    isAudit, // audit_mode
+                    JSON.stringify(config),
+                    (msg, percent) => {
+                        try {
+                            if (msg.startsWith('{')) {
+                                const info = JSON.parse(msg);
+
+                                for (const [key, config] of Object.entries(agentMap)) {
+                                    const item = info[key];
+                                    if (!item) continue;
+
+                                    const agentStatus = item.status || 'pending';
+                                    const values = item.values || [];
+
+                                    let displayMsg = `${config.label}: ${agentStatus.charAt(0).toUpperCase() + agentStatus.slice(1)}...`;
+                                    if (agentStatus === 'completed') displayMsg = `${config.label}: Completed`;
+
+                                    if (values.length > 0) {
+                                        const vals = values.map(v => v.toString().replace(/_/g, ' ')).slice(0, 2).join(', ');
+                                        displayMsg += ` (${vals}${values.length > 2 ? '...' : ''})`;
+                                    }
+
+                                    progress.update(displayMsg, {
+                                        percent: key === 'behavior_expert_status' ? percent : undefined,
+                                        explicit_step: config.step,
+                                        step_increment: false
+                                    });
+                                }
+                            } else {
+                                progress.update(msg, { percent });
+                            }
+                        } catch (e) {
+                            progress.update(msg, { percent });
+                        }
+                    }
+                );
+
+                if (isAudit) {
+                    // Auto-exit the progress UI so we can immediately show the audit results
+                    progress.complete('Audit complete!', { auto_exit: true });
+                    return {
+                        message: 'Audit complete!',
+                        resultJson: resultJson
+                    };
+                }
+
+                progress.update('Tests generated successfully!');
+
+                return {
+                    message: 'Tests generated successfully!',
+                    resultJson
+                };
+            } catch (e) {
+                progress.error(`Failed to generate: ${e.message}`);
+                return { error: e.message };
+            }
+        };
+
+        const uiResult = await this.goUiSession.showProgress(`${actionName} ${displayName}`, progressHandler);
+
+        if (isAudit && uiResult && uiResult.resultJson) {
+            const auditData = JSON.parse(uiResult.resultJson);
+            // Unwrap 'audit_results' if present (Ruby wrapper does this, but JS output might differ)
+            return this.goUiSession.showAuditResults(auditData);
+        }
+
+        if (uiResult && uiResult.resultJson) {
+            const fileInfo = await saveTestFile(uiResult.resultJson);
+            return {
+                ...uiResult,
+                file_path: fileInfo?.file_path
+            };
+        }
+
+        return null;
+    }
+
+    _showPostGenerationMenu(result) {
+        const filePath = result.file_path;
+        const runCommand = `npm test ${filePath}`; // Example command
+
+        while (true) {
+            const choice = this.goUiSession.showPostGenerationMenu(filePath, runCommand);
+            if (choice === 'back' || !choice) break;
+
+            if (choice === 'copy_command') {
+                this._copyToClipboard(runCommand);
+            }
+        }
+    }
+
+    _copyToClipboard(text) {
+        const { execSync } = require('child_process');
+        try {
+            if (process.platform === 'darwin') {
+                execSync('pbcopy', { input: text });
+            } else {
+                // Simplified for now
+                console.log(`\n📋 Copy this command: ${text}\n`);
+            }
+        } catch (e) { }
+    }
+
+    async _getUserFiles() {
+        const patterns = ['**/*.{js,ts,jsx,tsx}'];
+        const ignore = [
+            '**/node_modules/**',
+            '**/dist/**',
+            '**/build/**',
+            '**/tests/**',
+            '**/test/**',
+            '**/*.test.*',
+            '**/*.spec.*'
+        ];
+
+        return glob(patterns, {
+            ignore,
+            absolute: true,
+            onlyFiles: true
+        });
+    }
+}
+
+module.exports = GenerateTestsUI;

package/lib/goUiSession.js

@@ -0,0 +1,349 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { spawn, spawnSync } = require('child_process');
+
+class GoUISession {
+    constructor() {
+        this._binaryPath = this._findGoUiBinary();
+        this._running = false;
+    }
+
+    start() {
+        this._running = true;
+    }
+
+    stop() {
+        this._running = false;
+    }
+
+    running() {
+        return this._running;
+    }
+
+    showMenu() {
+        const outputFile = this._createTempFile('menu-output', '.txt');
+
+        try {
+            spawnSync(this._binaryPath, ['menu', '--output', outputFile], {
+                stdio: 'inherit'
+            });
+
+            if (!fs.existsSync(outputFile) || fs.statSync(outputFile).size === 0) {
+                return 'exit';
+            }
+
+            const choice = fs.readFileSync(outputFile, 'utf8').trim();
+            return choice || 'exit';
+        } catch (error) {
+            console.error('Menu error:', error);
+            return 'exit';
+        } finally {
+            this._cleanupTempFile(outputFile);
+        }
+    }
+
+    showJsTestMenu() {
+        const outputFile = this._createTempFile('js-menu-output', '.txt');
+
+        try {
+            spawnSync(this._binaryPath, ['js-test-menu', '--output', outputFile], {
+                stdio: 'inherit'
+            });
+
+            if (!fs.existsSync(outputFile) || fs.statSync(outputFile).size === 0) {
+                return 'back';
+            }
+
+            const choice = fs.readFileSync(outputFile, 'utf8').trim();
+            return choice || 'back';
+        } catch (error) {
+            console.error('JS API Menu error:', error);
+            return 'back';
+        } finally {
+            this._cleanupTempFile(outputFile);
+        }
+    }
+
+    showListView(title, items) {
+        const dataJson = JSON.stringify({ title, items });
+        const outputFile = this._createTempFile('list-view-output', '.txt');
+
+        try {
+            spawnSync(this._binaryPath, ['list-view', '--data', dataJson, '--output', outputFile], {
+                stdio: 'inherit'
+            });
+
+            if (!fs.existsSync(outputFile) || fs.statSync(outputFile).size === 0) {
+                return 'back';
+            }
+
+            const selected = fs.readFileSync(outputFile, 'utf8').trim();
+            return selected || 'back';
+        } catch (error) {
+            console.error('List view error:', error);
+            return 'back';
+        } finally {
+            this._cleanupTempFile(outputFile);
+        }
+    }
+
+    showSpinner(message, func) {
+        const controlFile = this._createTempFile('spinner-control', '.json');
+
+        // Start spinner in background
+        const process = spawn(this._binaryPath, ['spinner', '--message', message, '--control', controlFile], {
+            stdio: ['ignore', 'inherit', 'inherit']
+        });
+
+        try {
+            const result = func();
+
+            const status = {
+                status: result && result.success ? 'success' : 'error',
+                message: (result && result.message) || 'Done!'
+            };
+
+            fs.writeFileSync(controlFile, JSON.stringify(status));
+
+            // Wait for process to exit
+            // In Node, we can't easily wait sync for background spawned process without busy loop or async
+            // But for this simple implementation, we'll wait for the process to exit
+        } catch (error) {
+            const status = { status: 'error', message: error.message };
+            fs.writeFileSync(controlFile, JSON.stringify(status));
+            throw error;
+        } finally {
+            // We don't delete controlFile immediately here if process is still running
+            // but spawnSync/wait logic would be better.
+            // For now, let's keep it simple.
+        }
+    }
+
+    showStats(statsData) {
+        const statsJson = JSON.stringify(statsData || {});
+        try {
+            spawnSync(this._binaryPath, ['stats', '--data', statsJson], {
+                stdio: 'inherit'
+            });
+        } catch (error) {
+            console.error('Stats error:', error);
+        }
+    }
+
+    showAbout() {
+        try {
+            spawnSync(this._binaryPath, ['about'], {
+                stdio: 'inherit'
+            });
+        } catch (error) {
+            console.error('About error:', error);
+        }
+    }
+
+    showPostGenerationMenu(filePath, runCommand) {
+        const dataJson = JSON.stringify({ file_path: filePath, run_command: runCommand });
+        const outputFile = this._createTempFile('post-gen-output', '.txt');
+
+        try {
+            spawnSync(this._binaryPath, ['post-generation-menu', '--data', dataJson, '--output', outputFile], {
+                stdio: 'inherit'
+            });
+
+            if (!fs.existsSync(outputFile) || fs.statSync(outputFile).size === 0) {
+                return 'back';
+            }
+
+            return fs.readFileSync(outputFile, 'utf8').trim() || 'back';
+        } catch (error) {
+            console.error('Post-gen menu error:', error);
+            return 'back';
+        } finally {
+            this._cleanupTempFile(outputFile);
+        }
+    }
+
+    async showProgress(title, handler) {
+        const controlFile = this._createTempFile('progress-control', '.json');
+
+        // Spawn progress in background
+        const child = spawn(this._binaryPath, ['progress', '--title', title, '--control', controlFile], {
+            stdio: ['ignore', 'inherit', 'inherit'],
+            env: process.env
+        });
+
+        const processPromise = new Promise((resolve) => {
+            child.on('exit', () => resolve());
+            child.on('error', () => resolve());
+        });
+
+        let stepCounter = 0;
+        const progress = {
+            update: (message, options = {}) => {
+                const stepIdx = options.explicit_step !== undefined ?
+                    options.explicit_step :
+                    (options.step_increment === false ? (stepCounter > 0 ? stepCounter - 1 : 0) : stepCounter);
+
+                const data = {
+                    type: 'step',
+                    step: stepIdx,
+                    message: message
+                };
+
+                if (options.percent !== undefined) {
+                    data.percent = options.percent;
+                }
+
+                fs.writeFileSync(controlFile, JSON.stringify(data));
+
+                if (options.explicit_step === undefined && options.step_increment !== false) {
+                    stepCounter++;
+                }
+
+                // Small delay to ensure Go UI (polling at 100ms) doesn't miss rapid updates
+                if (options.explicit_step !== undefined) {
+                    spawnSync('sleep', ['0.05']);
+                }
+            },
+            error: (message) => {
+                const data = { type: 'error', message };
+                fs.writeFileSync(controlFile, JSON.stringify(data));
+            },
+            complete: (message, options = {}) => {
+                const data = {
+                    type: 'complete',
+                    message: message || 'Done!',
+                    auto_exit: options.auto_exit === true
+                };
+                fs.writeFileSync(controlFile, JSON.stringify(data));
+            }
+        };
+
+        try {
+            const result = await handler(progress);
+            // Signal success if not already completed/errored
+            progress.complete();
+
+            // Wait for progress bar to exit CLEANLY
+            await processPromise;
+
+            return result;
+        } catch (error) {
+            progress.error(error.message);
+            await processPromise; // Wait even on error
+            throw error;
+            // If the process was killed or died, exitCode will be set.
+        }
+    }
+
+
+    showClipboardSuccess(command) {
+        spawnSync(this._binaryPath, ['clipboard-success', '--command', command], {
+            stdio: 'inherit'
+        });
+    }
+
+    showTestResults(title, passed, failed, errors, total, results = []) {
+        const dataJson = JSON.stringify({ title, passed, failed, errors, total, results });
+        spawnSync(this._binaryPath, ['test-results', '--data', dataJson], {
+            stdio: 'inherit'
+        });
+    }
+
+    async showAuditResults(auditResult) {
+        const dataJson = JSON.stringify(auditResult);
+        const inputFile = this._createTempFile('audit-data', '.json');
+        const outputFile = this._createTempFile('audit-choice', '.txt');
+
+        try {
+            fs.writeFileSync(inputFile, dataJson);
+
+            // Pause stdin to allow child process to take control of TTY
+            if (process.stdin.setRawMode) {
+                process.stdin.setRawMode(false);
+            }
+            process.stdin.pause();
+
+            await new Promise((resolve, reject) => {
+                const child = spawn(this._binaryPath, ['audit-results', '--file', inputFile, '--output', outputFile], {
+                    stdio: ['inherit', 'inherit', 'inherit'],
+                    env: process.env
+                });
+
+                child.on('error', (err) => {
+                    reject(err);
+                });
+
+                child.on('exit', (code) => {
+                    resolve();
+                });
+            });
+
+            if (!fs.existsSync(outputFile) || fs.statSync(outputFile).size === 0) {
+                return 'back';
+            }
+
+            return fs.readFileSync(outputFile, 'utf8').trim() || 'back';
+        } catch (error) {
+            console.error('Audit results error:', error);
+            return 'back';
+        } finally {
+            // Resume stdin
+            process.stdin.resume();
+
+            this._cleanupTempFile(inputFile);
+            this._cleanupTempFile(outputFile);
+        }
+    }
+
+    showNoItems(itemType) {
+        try {
+            spawnSync(this._binaryPath, ['no-items', '--type', itemType], {
+                stdio: 'inherit'
+            });
+        } catch (error) {
+            console.error('No items error:', error);
+        }
+    }
+
+    _findGoUiBinary() {
+        const platform = process.platform;
+        const arch = process.arch;
+        let binaryName = '';
+
+        if (platform === 'darwin') {
+            binaryName = arch === 'arm64' ? 'go-ui-darwin-arm64' : 'go-ui-darwin-amd64';
+        } else if (platform === 'linux') {
+            binaryName = arch === 'arm64' ? 'go-ui-linux-arm64' : 'go-ui-linux-amd64';
+        } else {
+            throw new Error(`Unsupported platform: ${platform}`);
+        }
+
+        // Look in binaries folder relative to this file
+        const localBinary = path.join(__dirname, '..', 'binaries', binaryName);
+        if (fs.existsSync(localBinary)) {
+            return localBinary;
+        }
+
+        throw new Error(`go-ui binary not found: ${localBinary}`);
+    }
+
+    _createTempFile(prefix, suffix) {
+        const tmpDir = os.tmpdir();
+        const filePath = path.join(tmpDir, `${prefix}-${Date.now()}-${Math.floor(Math.random() * 1000)}${suffix}`);
+        fs.writeFileSync(filePath, '');
+        return filePath;
+    }
+
+    _cleanupTempFile(filePath) {
+        if (fs.existsSync(filePath)) {
+            try {
+                fs.unlinkSync(filePath);
+            } catch (e) {
+                // Ignore cleanup errors
+            }
+        }
+    }
+}
+
+module.exports = GoUISession;