@tng-sh/js 0.0.9 → 0.1.1

package/lib/generateTestsUi.js

@@ -3,9 +3,10 @@ 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 { getFileOutline, generateTest, ping, getUserStats } = require('../index');
 const { loadConfig } = require('./config');
 const { saveTestFile } = require('./saveFile');
+const { applyFix } = require('./fixApplier');
 
 class GenerateTestsUI {
     constructor(cliMode = false) {
@@ -52,16 +53,19 @@ class GenerateTestsUI {
             config_file: "tng.config.js"
         });
 
-        spawnSync(this.goUiSession._binaryPath, ['config-missing', '--data', dataJson], {
-            stdio: 'inherit'
-        });
+        try {
+            spawnSync(this.goUiSession._binaryPath, ['config-missing', '--data', dataJson], {
+                stdio: 'inherit'
+            });
+        } catch (e) {
+            console.error(chalk.red('\nFailed to show configuration error UI.\n'));
+        }
     }
 
     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;
         }
 
@@ -78,7 +82,6 @@ class GenerateTestsUI {
         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;
         }
 
@@ -96,7 +99,7 @@ class GenerateTestsUI {
         const files = await this._getUserFiles();
 
         if (files.length === 0) {
-            console.log(chalk.yellow('No JS/TS files found in project.'));
+            console.log(chalk.yellow('\nNo JavaScript or TypeScript files found in your project.\n'));
             return 'back';
         }
 
@@ -124,8 +127,8 @@ class GenerateTestsUI {
             const result = getFileOutline(filePath);
             outline = JSON.parse(result);
         } catch (e) {
-            console.error(chalk.red(`Error parsing file: ${e.message}`));
-            return this._showFileSelection();
+            console.error(chalk.red(`\nError parsing file: ${e.message}\n`));
+            return this._showFileSelection(isAudit);
         }
 
         const methods = outline.methods || [];
@@ -144,8 +147,7 @@ class GenerateTestsUI {
         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);
+        if (selectedDisplay === 'back' || !selectedDisplay) return this._showFileSelection(isAudit);
 
         const selectedMethod = items.find(i => i.name === selectedDisplay)?.methodData;
 
@@ -154,7 +156,6 @@ class GenerateTestsUI {
             if (testType === 'back') return this._showFileSelection(isAudit);
 
             const finalType = testType === 'auto' ? null : testType;
-
             const choice = await this._generateTestsForMethod(filePath, selectedMethod, finalType, isAudit);
 
             if (isAudit) {
@@ -170,88 +171,215 @@ class GenerateTestsUI {
     }
 
     async _generateTestsForMethod(filePath, method, testType, isAudit = false) {
+        if (!this._hasApiKey()) {
+            return { error: 'No API key' };
+        }
+
+        if (isAudit) {
+            return this._handleAuditFlow(filePath, method, testType);
+        }
+
         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';
+        return this._handleTestGenerationFlow(filePath, method, testType, displayName);
+    }
 
-        const progressHandler = async (progress) => {
-            progress.update('Preparing request...');
+    _hasApiKey() {
+        const config = loadConfig();
+        if (!config.API_KEY) {
+            const msg = 'No API key configured. Run: tng init';
+            if (this.cliMode) console.log(chalk.red(msg));
+            return false;
+        }
+        return true;
+    }
 
-            try {
-                const config = loadConfig();
-                if (!config.API_KEY) {
-                    progress.error('No API key configured. Run: tng init');
-                    return { error: 'No API key' };
-                }
+    async _handleAuditFlow(filePath, method, testType) {
+        const { Worker } = require('worker_threads');
+        const streamingUi = await this.goUiSession.showStreamingAuditResults(
+            method.name,
+            method.class_name,
+            method.source_code || ''
+        );
+
+        if (!streamingUi) return null;
+
+        let results = {
+            issues: [],
+            behaviours: [],
+            method_name: method.name,
+            class_name: method.class_name,
+            method_source_with_lines: method.source_code
+        };
+        let auditFinished = false;
 
-                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 }
-                };
+        // Start audit in background worker
+        const worker = new Worker(path.join(__dirname, 'auditWorker.js'), {
+            workerData: { filePath, methodName: method.name, className: method.class_name || null, testType: testType || null }
+        });
 
-                for (const [key, config] of Object.entries(agentMap)) {
-                    progress.update(`${config.label}: Pending...`, { step_increment: true });
+        const itemIds = new Set();
+        worker.on('message', (msg) => {
+            if (msg.type === 'item') {
+                if (msg.data.startsWith('{')) {
+                    streamingUi.write(msg.data);
+                    try {
+                        const data = JSON.parse(msg.data);
+
+                        // Handle metadata updates from stream
+                        if (data.method_name) results.method_name = data.method_name;
+                        if (data.class_name) results.class_name = data.class_name;
+                        if (data.method_source_with_lines) results.method_source_with_lines = data.method_source_with_lines;
+                        if (data.source_code) results.method_source_with_lines = data.source_code;
+
+                        // Only push if it looks like an actual audit item
+                        if (data.test_name || data.summary || data.category) {
+                            const id = `${data.category}-${data.test_name}-${data.line_number}`;
+                            if (!itemIds.has(id)) {
+                                if (data.category === 'behavior' || data.category === 'behaviour') results.behaviours.push(data);
+                                else results.issues.push(data);
+                                itemIds.add(id);
+                            }
+                        }
+                    } catch (e) { }
                 }
+            } else if (msg.type === 'result') {
+                try {
+                    const finalResults = typeof msg.data === 'string' ? JSON.parse(msg.data) : msg.data;
+
+                    // Merge final results with our local ones, preserving 'fixed' state
+                    const mergeList = (localList, incomingList) => {
+                        if (!incomingList || incomingList.length === 0) return localList;
+
+                        return incomingList.map(incomingItem => {
+                            const localItem = localList.find(it =>
+                                it.test_name === incomingItem.test_name &&
+                                it.line_number === incomingItem.line_number
+                            );
+                            if (localItem && localItem.fixed) {
+                                return { ...incomingItem, fixed: true };
+                            }
+                            return incomingItem;
+                        });
+                    };
 
-                // 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);
+                    results.issues = mergeList(results.issues, finalResults.issues || finalResults.findings);
+                    results.behaviours = mergeList(results.behaviours, finalResults.behaviours);
 
-                                for (const [key, config] of Object.entries(agentMap)) {
-                                    const item = info[key];
-                                    if (!item) continue;
+                    if (finalResults.method_source_with_lines) results.method_source_with_lines = finalResults.method_source_with_lines;
+                    if (finalResults.method_name) results.method_name = finalResults.method_name;
+                } catch (e) { }
+                auditFinished = true;
+            } else if (msg.type === 'error') {
+                console.error(chalk.red(`Audit error: ${msg.data}`));
+                auditFinished = true;
+            }
+        });
 
-                                    const agentStatus = item.status || 'pending';
-                                    const values = item.values || [];
+        worker.on('error', (err) => {
+            console.error(chalk.red(`Worker error: ${err.message}`));
+            auditFinished = true;
+        });
 
-                                    let displayMsg = `${config.label}: ${agentStatus.charAt(0).toUpperCase() + agentStatus.slice(1)}...`;
-                                    if (agentStatus === 'completed') displayMsg = `${config.label}: Completed`;
+        try {
+            let currentChoice = null;
 
-                                    if (values.length > 0) {
-                                        const vals = values.map(v => v.toString().replace(/_/g, ' ')).slice(0, 2).join(', ');
-                                        displayMsg += ` (${vals}${values.length > 2 ? '...' : ''})`;
-                                    }
+            // Wait for INITIAL streaming session to complete (user picks an action or quits)
+            await streamingUi.wait;
 
-                                    progress.update(displayMsg, {
-                                        percent: key === 'behavior_expert_status' ? percent : undefined,
-                                        explicit_step: config.step,
-                                        step_increment: false
-                                    });
-                                }
-                            } else {
-                                progress.update(msg, { percent });
-                            }
+            const getResponse = (outputFile) => {
+                if (fs.existsSync(outputFile)) {
+                    const output = fs.readFileSync(outputFile, 'utf8').trim();
+                    if (output) {
+                        try {
+                            const parsed = JSON.parse(output);
+                            return typeof parsed === 'object' ? parsed : { action: output };
                         } catch (e) {
-                            progress.update(msg, { percent });
+                            return { action: output };
                         }
                     }
-                );
+                }
+                return null;
+            };
+
+            currentChoice = getResponse(streamingUi.outputFile);
+
+            // Action loop: handles fix/open and returns to UI
+            while (currentChoice && (currentChoice.action === 'fix' || currentChoice.action === 'open')) {
+                const itemIndex = typeof currentChoice.index === 'number' ? currentChoice.index : 0;
+
+                if (currentChoice.action === 'fix') {
+                    console.log(chalk.cyan(`Applying fix...`));
+                    const fixResult = await applyFix(filePath, currentChoice.item);
+                    if (fixResult.success) {
+                        console.log(chalk.green(`✓ Fix applied successfully.`));
+                        // Mark as fixed locally
+                        [results.issues, results.behaviours].forEach(list => {
+                            list.forEach(it => {
+                                if (it.test_name === currentChoice.item.test_name && it.line_number === currentChoice.item.line_number) {
+                                    it.fixed = true;
+                                }
+                            });
+                        });
+                    } else {
+                        console.log(chalk.red(`❌ Failed to apply fix: ${fixResult.error || 'Unknown error'}`));
+                    }
+                } else if (currentChoice.action === 'open') {
+                    this._openInEditor(filePath, currentChoice.item.line_number);
+                }
 
-                if (isAudit) {
-                    progress.complete('Audit ready!', { auto_exit: false });
-                    return {
-                        message: 'Audit ready!',
-                        resultJson: resultJson
-                    };
+                // Ensure source has line numbers for static UI if it doesn't already
+                if (results.method_source_with_lines && !/^\s*\d+:/.test(results.method_source_with_lines)) {
+                    results.method_source_with_lines = results.method_source_with_lines
+                        .split('\n')
+                        .map((line, i) => `${i + 1}: ${line}`)
+                        .join('\n');
                 }
 
-                progress.update('Tests generated successfully!');
+                // Re-launch UI statically with updated results
+                const choiceStr = await this.goUiSession.showAuditResults(results, itemIndex);
+                if (choiceStr === 'back' || choiceStr === 'main_menu' || choiceStr === 'exit') {
+                    currentChoice = null;
+                } else {
+                    try {
+                        const parsed = JSON.parse(choiceStr);
+                        currentChoice = typeof parsed === 'object' ? parsed : { action: choiceStr };
+                    } catch (e) {
+                        currentChoice = { action: choiceStr };
+                    }
+                }
+            }
 
-                // Save the file inside the progress handler to match Python flow
-                const fileInfo = await saveTestFile(resultJson);
+            return { message: 'Audit complete', results };
+        } catch (e) {
+            console.error(chalk.red(`\nAudit flow failed: ${e.message}\n`));
+            return null;
+        } finally {
+            await worker.terminate();
+        }
+    }
+
+    async _handleTestGenerationFlow(filePath, method, testType, displayName) {
+        const actionName = 'Generating test for';
+
+        const progressHandler = async (progress) => {
+            progress.update('Preparing request...');
+
+            try {
+                const config = loadConfig();
 
+                const resultJson = generateTest(
+                    filePath,
+                    method.name,
+                    method.class_name || null,
+                    testType || null,
+                    JSON.stringify(config),
+                    (msg, percent) => this._updateProgress(progress, msg, percent)
+                );
+
+                progress.update('Saving generated tests...');
+
+                const fileInfo = await saveTestFile(resultJson);
                 return {
                     message: 'Tests generated successfully!',
                     resultJson,
@@ -264,23 +392,54 @@ class GenerateTestsUI {
         };
 
         const uiResult = await this.goUiSession.showProgress(`${actionName} ${displayName}`, progressHandler);
+        return uiResult || null;
+    }
 
-        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);
-        }
+    _updateProgress(progress, msg, percent) {
+        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 }
+        };
 
-        if (uiResult && uiResult.resultJson) {
-            return uiResult;
-        }
+        try {
+            if (msg.trim().startsWith('{')) {
+                const info = JSON.parse(msg);
+
+                for (const [key, config] of Object.entries(agentMap)) {
+                    const item = info[key];
+                    if (!item) continue;
 
-        return null;
+                    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 });
+        }
     }
 
     _showPostGenerationMenu(result) {
         const filePath = result.file_path;
-        const runCommand = `npm test ${filePath}`; // Example command
+        const runCommand = `npm test ${filePath}`;
 
         while (true) {
             const choice = this.goUiSession.showPostGenerationMenu(filePath, runCommand);
@@ -308,20 +467,17 @@ class GenerateTestsUI {
                 };
             } catch (error) {
                 return {
-                    success: true, // We still want to show the results even if tests failed
-                    message: "Tests completed",
-                    output: error.stdout + error.stderr,
-                    exit_code: error.status
+                    success: true,
+                    message: "Tests completed with failures",
+                    output: (error.stdout || '') + (error.stderr || ''),
+                    exit_code: error.status || 1
                 };
             }
         };
 
         const testOutput = this.goUiSession.showSpinner("Running tests...", spinnerHandler);
 
-        // Note: For simplicity in the first pass, we provide counts.
-        // We can enhance _parseTestOutput if needed.
         const { passed, failed, errors, total } = this._parseTestOutput(testOutput.output || "", testOutput.exit_code || 0);
-
         this.goUiSession.showTestResults("Test Results", passed, failed, errors, total, []);
     }
 
@@ -356,11 +512,41 @@ class GenerateTestsUI {
         try {
             if (process.platform === 'darwin') {
                 execSync('pbcopy', { input: text });
+                this.goUiSession.showClipboardSuccess(text);
+            } else if (process.platform === 'linux') {
+                // Try xclip then xsel
+                try {
+                    execSync('xclip -selection clipboard', { input: text });
+                } catch (e) {
+                    execSync('xsel --clipboard --input', { input: text });
+                }
+                this.goUiSession.showClipboardSuccess(text);
             } else {
-                // Simplified for now
-                console.log(`\n📋 Copy this command: ${text}\n`);
+                console.log(chalk.cyan(`\n📋 Please copy this command: ${text}\n`));
+            }
+        } catch (e) {
+            console.error(chalk.yellow(`\n⚠️  Failed to copy to clipboard. Command: ${text}\n`));
+        }
+    }
+
+    _openInEditor(filePath, lineNumber) {
+        const { execSync } = require('child_process');
+        try {
+            // Try to open in VS Code if available, fallback to default editor
+            const location = lineNumber ? `${filePath}:${lineNumber}` : filePath;
+            try {
+                execSync(`code --goto ${location}`, { stdio: 'ignore' });
+                console.log(chalk.blue(`\nOpening ${location} in VS Code...`));
+            } catch (e) {
+                if (process.platform === 'darwin') {
+                    execSync(`open ${filePath}`);
+                } else if (process.platform === 'linux') {
+                    execSync(`xdg-open ${filePath}`);
+                }
             }
-        } catch (e) { }
+        } catch (e) {
+            console.log(chalk.yellow(`\n⚠️ Failed to open editor: ${e.message}`));
+        }
     }
 
     async _getUserFiles() {
@@ -375,11 +561,16 @@ class GenerateTestsUI {
             '**/*.spec.*'
         ];
 
-        return glob(patterns, {
-            ignore,
-            absolute: true,
-            onlyFiles: true
-        });
+        try {
+            return await glob(patterns, {
+                ignore,
+                absolute: true,
+                onlyFiles: true
+            });
+        } catch (e) {
+            console.error(chalk.red(`\nError searching for files: ${e.message}\n`));
+            return [];
+        }
     }
 }