@tng-sh/js 0.0.8 → 0.1.0

package/bin/tng.js

@@ -8,10 +8,26 @@ const { loadConfig } = require('../lib/config');
 const { saveTestFile } = require('../lib/saveFile');
 const { ping, getUserStats } = require('../index');
 
+// Handle EPIPE errors gracefully when child process (Go UI) exits
+process.stdout.on('error', (err) => {
+    if (err.code === 'EPIPE') {
+        // Ignore - this happens when Go UI exits and we try to write to closed pipe
+        process.exit(0);
+    }
+});
+
+process.on('uncaughtException', (err) => {
+    if (err.code === 'EPIPE') {
+        // Ignore broken pipe - child process exited
+        process.exit(0);
+    }
+    throw err; // Re-throw other errors
+});
+
 program
     .name('tng')
     .description('TNG - Automated Test Generation, and audit generation for JavaScript')
-    .version('0.0.8');
+    .version('0.1.0');
 
 /**
  * @command init
@@ -188,7 +204,7 @@ async function generateTest(filePath, methodName, testType, auditMode = false, j
         process.exit(1);
     }
 
-    const { submitAndPoll } = require('../index');
+    const { runAudit, generateTest: nativeGenerateTest } = require('../index');
 
     const action = auditMode ? 'Auditing' : 'Generating test for';
     const startMessage = `🔍 ${action} ${methodName} in ${filePath}...`;
@@ -201,31 +217,45 @@ async function generateTest(filePath, methodName, testType, auditMode = false, j
     } else {
         console.log(chalk.blue(startMessage));
         if (testType) {
-            console.log(chalk.cyan(`ℹ️  Type hint: ${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}`));
-                    }
+        let resultJson;
+
+        const callback = (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) {
+            resultJson = runAudit(
+                absolutePath,
+                methodName,
+                null, // class_name
+                testType || null,
+                JSON.stringify(config),
+                callback
+            );
+        } else {
+            resultJson = nativeGenerateTest(
+                absolutePath,
+                methodName,
+                null, // class_name
+                testType || null,
+                JSON.stringify(config),
+                callback
+            );
+        }
 
         if (auditMode) {
             // In audit mode, display the results

package/index.d.ts

@@ -3,10 +3,34 @@
 
 /* auto-generated by NAPI-RS */
 
+/**
+ * Analyzes a JavaScript/TypeScript file and returns its structural outline as a JSON string.
+ * Contains information about classes and methods found in the file.
+ */
 export declare function getFileOutline(filePath: string): string
+/**
+ * Gathers project-wide metadata from package.json and related files.
+ * Returns a JSON string containing dependencies, frameworks, and project type.
+ */
 export declare function getProjectMetadata(projectRoot: string): string
+/**
+ * Searches the project for all locations where a specific method is called.
+ * Uses ripgrep under the hood for high performance.
+ */
 export declare function findCallSites(projectRoot: string, methodName: string): string
+/** Pings the TNG API to verify connectivity and API key validity. */
 export declare function ping(baseUrl: string, apiKey?: string | undefined | null): string
+/** Submits a test generation job to the API and returns the numeric job ID. */
 export declare function submitJob(baseUrl: string, apiKey: string, payloadJson: string): number
+/** Fetches usage statistics for the authenticated user from the API. */
 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
+/**
+ * Orchestrates the code audit process.
+ * Analyzes the source, builds context, and streams results via the provided callback.
+ */
+export declare function runAudit(filePath: string, methodName: string, className: string | undefined | null, testType: string | undefined | null, configJson: string, callback: (...args: any[]) => any): string
+/**
+ * Orchestrates the test generation process.
+ * Analyzes code, submits a job, and polls for the final generated test.
+ */
+export declare function generateTest(filePath: string, methodName: string, className: string | undefined | null, testType: string | undefined | null, configJson: string, callback: (...args: any[]) => any): string

package/index.js

@@ -310,7 +310,7 @@ if (!nativeBinding) {
   throw new Error(`Failed to load native binding`)
 }
 
-const { getFileOutline, getProjectMetadata, findCallSites, ping, submitJob, getUserStats, submitAndPoll } = nativeBinding
+const { getFileOutline, getProjectMetadata, findCallSites, ping, submitJob, getUserStats, runAudit, generateTest } = nativeBinding
 
 module.exports.getFileOutline = getFileOutline
 module.exports.getProjectMetadata = getProjectMetadata
@@ -318,4 +318,5 @@ module.exports.findCallSites = findCallSites
 module.exports.ping = ping
 module.exports.submitJob = submitJob
 module.exports.getUserStats = getUserStats
-module.exports.submitAndPoll = submitAndPoll
+module.exports.runAudit = runAudit
+module.exports.generateTest = generateTest

package/lib/generateTestsUi.js

@@ -1,9 +1,8 @@
-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 { getFileOutline, runAudit, generateTest, ping, getUserStats } = require('../index');
 const { loadConfig } = require('./config');
 const { saveTestFile } = require('./saveFile');
 
@@ -52,16 +51,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 +80,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 +97,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 +125,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 +145,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 +154,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 +169,82 @@ 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);
+    }
+
+    _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;
+    }
+
+    async _handleAuditFlow(filePath, method, testType) {
+        const config = loadConfig();
+        const streamingUi = await this.goUiSession.showStreamingAuditResults(
+            method.name,
+            method.class_name,
+            method.source_code || ''
+        );
+
+        if (!streamingUi) return null;
+
+        try {
+            const resultJson = runAudit(
+                filePath,
+                method.name,
+                method.class_name || null,
+                testType || null,
+                JSON.stringify(config),
+                (msg) => {
+                    if (msg.startsWith('{')) {
+                        streamingUi.write(msg);
+                    }
+                }
+            );
+
+            await streamingUi.wait;
+            return { message: 'Audit complete', resultJson };
+        } catch (e) {
+            console.error(chalk.red(`\nAudit failed: ${e.message}\n`));
+            return null;
+        }
+    }
+
+    async _handleTestGenerationFlow(filePath, method, testType, displayName) {
+        const actionName = 'Generating test for';
 
         const progressHandler = async (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(
+                const resultJson = generateTest(
                     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 });
-                        }
-                    }
+                    (msg, percent) => this._updateProgress(progress, msg, percent)
                 );
 
-                if (isAudit) {
-                    progress.complete('Audit ready!', { auto_exit: false });
-                    return {
-                        message: 'Audit ready!',
-                        resultJson: resultJson
-                    };
-                }
-
-                progress.update('Tests generated successfully!');
+                progress.update('Saving generated tests...');
 
-                // Save the file inside the progress handler to match Python flow
                 const fileInfo = await saveTestFile(resultJson);
-
                 return {
                     message: 'Tests generated successfully!',
                     resultJson,
@@ -264,23 +257,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;
+
+                    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 ? '...' : ''})`;
+                    }
 
-        return null;
+                    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 +332,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 +377,21 @@ 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) { }
+        } catch (e) {
+            console.error(chalk.yellow(`\n⚠️  Failed to copy to clipboard. Command: ${text}\n`));
+        }
     }
 
     async _getUserFiles() {
@@ -375,11 +406,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 [];
+        }
     }
 }
 

package/lib/goUiSession.js

@@ -7,6 +7,7 @@ class GoUISession {
     constructor() {
         this._binaryPath = this._findGoUiBinary();
         this._running = false;
+        this._tempFiles = new Set();
     }
 
     start() {
@@ -15,20 +16,30 @@ class GoUISession {
 
     stop() {
         this._running = false;
+        this.cleanup();
     }
 
     running() {
         return this._running;
     }
 
+    cleanup() {
+        for (const file of this._tempFiles) {
+            this._cleanupTempFile(file);
+        }
+        this._tempFiles.clear();
+    }
+
     showMenu() {
-        const outputFile = this._createTempFile('menu-output', '.txt');
+        const outputFile = this._trackTempFile(this._createTempFile('menu-output', '.txt'));
 
         try {
-            spawnSync(this._binaryPath, ['menu', '--output', outputFile], {
+            const result = spawnSync(this._binaryPath, ['menu', '--output', outputFile], {
                 stdio: 'inherit'
             });
 
+            if (result.error) throw result.error;
+
             if (!fs.existsSync(outputFile) || fs.statSync(outputFile).size === 0) {
                 return 'exit';
             }
@@ -36,7 +47,7 @@ class GoUISession {
             const choice = fs.readFileSync(outputFile, 'utf8').trim();
             return choice || 'exit';
         } catch (error) {
-            console.error('Menu error:', error);
+            console.error('Menu error:', error.message);
             return 'exit';
         } finally {
             this._cleanupTempFile(outputFile);
@@ -44,13 +55,15 @@ class GoUISession {
     }
 
     showJsTestMenu() {
-        const outputFile = this._createTempFile('js-menu-output', '.txt');
+        const outputFile = this._trackTempFile(this._createTempFile('js-menu-output', '.txt'));
 
         try {
-            spawnSync(this._binaryPath, ['js-test-menu', '--output', outputFile], {
+            const result = spawnSync(this._binaryPath, ['js-test-menu', '--output', outputFile], {
                 stdio: 'inherit'
             });
 
+            if (result.error) throw result.error;
+
             if (!fs.existsSync(outputFile) || fs.statSync(outputFile).size === 0) {
                 return 'back';
             }
@@ -58,7 +71,7 @@ class GoUISession {
             const choice = fs.readFileSync(outputFile, 'utf8').trim();
             return choice || 'back';
         } catch (error) {
-            console.error('JS API Menu error:', error);
+            console.error('JS API Menu error:', error.message);
             return 'back';
         } finally {
             this._cleanupTempFile(outputFile);
@@ -67,13 +80,15 @@ class GoUISession {
 
     showListView(title, items) {
         const dataJson = JSON.stringify({ title, items });
-        const outputFile = this._createTempFile('list-view-output', '.txt');
+        const outputFile = this._trackTempFile(this._createTempFile('list-view-output', '.txt'));
 
         try {
-            spawnSync(this._binaryPath, ['list-view', '--data', dataJson, '--output', outputFile], {
+            const result = spawnSync(this._binaryPath, ['list-view', '--data', dataJson, '--output', outputFile], {
                 stdio: 'inherit'
             });
 
+            if (result.error) throw result.error;
+
             if (!fs.existsSync(outputFile) || fs.statSync(outputFile).size === 0) {
                 return 'back';
             }
@@ -81,7 +96,7 @@ class GoUISession {
             const selected = fs.readFileSync(outputFile, 'utf8').trim();
             return selected || 'back';
         } catch (error) {
-            console.error('List view error:', error);
+            console.error('List view error:', error.message);
             return 'back';
         } finally {
             this._cleanupTempFile(outputFile);
@@ -89,10 +104,9 @@ class GoUISession {
     }
 
     showSpinner(message, func) {
-        const controlFile = this._createTempFile('spinner-control', '.json');
+        const controlFile = this._trackTempFile(this._createTempFile('spinner-control', '.json'));
 
-        // Start spinner in background
-        const process = spawn(this._binaryPath, ['spinner', '--message', message, '--control', controlFile], {
+        const child = spawn(this._binaryPath, ['spinner', '--message', message, '--control', controlFile], {
             stdio: ['ignore', 'inherit', 'inherit']
         });
 
@@ -106,19 +120,20 @@ class GoUISession {
 
             fs.writeFileSync(controlFile, JSON.stringify(status));
 
-            // Wait for process to exit
-            // 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
+            // Wait for spinner to exit (it should exit after reading success/error from control file)
+            spawnSync('sleep', ['0.2']);
+
             return result;
         } catch (error) {
             const status = { status: 'error', message: error.message };
-            fs.writeFileSync(controlFile, JSON.stringify(status));
+            try { fs.writeFileSync(controlFile, JSON.stringify(status)); } catch (e) { }
             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.
+            // Give the child process a moment to exit before we delete the control file
+            setTimeout(() => {
+                this._cleanupTempFile(controlFile);
+                if (!child.killed) child.kill();
+            }, 500);
         }
     }
 
@@ -129,7 +144,7 @@ class GoUISession {
                 stdio: 'inherit'
             });
         } catch (error) {
-            console.error('Stats error:', error);
+            console.error('Stats error:', error.message);
         }
     }
 
@@ -139,26 +154,28 @@ class GoUISession {
                 stdio: 'inherit'
             });
         } catch (error) {
-            console.error('About error:', error);
+            console.error('About error:', error.message);
         }
     }
 
     showPostGenerationMenu(filePath, runCommand) {
         const dataJson = JSON.stringify({ file_path: filePath, run_command: runCommand });
-        const outputFile = this._createTempFile('post-gen-output', '.txt');
+        const outputFile = this._trackTempFile(this._createTempFile('post-gen-output', '.txt'));
 
         try {
-            spawnSync(this._binaryPath, ['post-generation-menu', '--data', dataJson, '--output', outputFile], {
+            const result = spawnSync(this._binaryPath, ['post-generation-menu', '--data', dataJson, '--output', outputFile], {
                 stdio: 'inherit'
             });
 
+            if (result.error) throw result.error;
+
             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);
+            console.error('Post-gen menu error:', error.message);
             return 'back';
         } finally {
             this._cleanupTempFile(outputFile);
@@ -166,9 +183,8 @@ class GoUISession {
     }
 
     async showProgress(title, handler) {
-        const controlFile = this._createTempFile('progress-control', '.json');
+        const controlFile = this._trackTempFile(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
@@ -196,20 +212,19 @@ class GoUISession {
                     data.percent = options.percent;
                 }
 
-                fs.writeFileSync(controlFile, JSON.stringify(data));
+                try {
+                    fs.writeFileSync(controlFile, JSON.stringify(data));
+                } catch (e) {
+                    // Silently fail if control file is locked or missing
+                }
 
                 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));
+                try { fs.writeFileSync(controlFile, JSON.stringify(data)); } catch (e) { }
             },
             complete: (message, options = {}) => {
                 const data = {
@@ -217,50 +232,51 @@ class GoUISession {
                     message: message || 'Done!',
                     auto_exit: options.auto_exit === true
                 };
-                fs.writeFileSync(controlFile, JSON.stringify(data));
+                try { fs.writeFileSync(controlFile, JSON.stringify(data)); } catch (e) { }
             }
         };
 
         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
+            await processPromise;
             throw error;
-            // If the process was killed or died, exitCode will be set.
+        } finally {
+            setTimeout(() => this._cleanupTempFile(controlFile), 500);
         }
     }
 
-
     showClipboardSuccess(command) {
-        spawnSync(this._binaryPath, ['clipboard-success', '--command', command], {
-            stdio: 'inherit'
-        });
+        try {
+            spawnSync(this._binaryPath, ['clipboard-success', '--command', command], {
+                stdio: 'inherit'
+            });
+        } catch (e) { }
     }
 
     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'
-        });
+        try {
+            spawnSync(this._binaryPath, ['test-results', '--data', dataJson], {
+                stdio: 'inherit'
+            });
+        } catch (error) {
+            console.error('Test results display error:', error.message);
+        }
     }
 
     async showAuditResults(auditResult) {
         const dataJson = JSON.stringify(auditResult);
-        const inputFile = this._createTempFile('audit-data', '.json');
-        const outputFile = this._createTempFile('audit-choice', '.txt');
+        const inputFile = this._trackTempFile(this._createTempFile('audit-data', '.json'));
+        const outputFile = this._trackTempFile(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);
             }
@@ -272,13 +288,8 @@ class GoUISession {
                     env: process.env
                 });
 
-                child.on('error', (err) => {
-                    reject(err);
-                });
-
-                child.on('exit', (code) => {
-                    resolve();
-                });
+                child.on('error', (err) => reject(err));
+                child.on('exit', () => resolve());
             });
 
             if (!fs.existsSync(outputFile) || fs.statSync(outputFile).size === 0) {
@@ -287,24 +298,75 @@ class GoUISession {
 
             return fs.readFileSync(outputFile, 'utf8').trim() || 'back';
         } catch (error) {
-            console.error('Audit results error:', error);
+            console.error('Audit results error:', error.message);
             return 'back';
         } finally {
-            // Resume stdin
             process.stdin.resume();
-
             this._cleanupTempFile(inputFile);
             this._cleanupTempFile(outputFile);
         }
     }
 
+    async showStreamingAuditResults(methodName, className, sourceCode) {
+        const outputFile = this._trackTempFile(this._createTempFile('audit-choice', '.txt'));
+
+        try {
+            if (process.stdin.setRawMode) {
+                process.stdin.setRawMode(false);
+            }
+            process.stdin.pause();
+
+            const child = spawn(this._binaryPath, [
+                'streaming-audit-results',
+                '--method', methodName || '',
+                '--class', className || '',
+                '--source', sourceCode || '',
+                '--output', outputFile
+            ], {
+                stdio: ['pipe', 'inherit', 'inherit'],
+                env: process.env
+            });
+
+            // Handle potential broken pipes defensively
+            child.stdin.on('error', (err) => {
+                if (err.code !== 'EPIPE' && err.code !== 'EOF') {
+                    console.error('Streaming stdin error:', err.message);
+                }
+            });
+
+            const processPromise = new Promise((resolve, reject) => {
+                child.on('error', (err) => reject(err));
+                child.on('exit', (code) => resolve(code));
+            });
+
+            return {
+                process: child,
+                wait: processPromise,
+                outputFile: outputFile,
+                write: (msg) => {
+                    if (child.stdin.writable) {
+                        try {
+                            child.stdin.write(msg + '\n');
+                        } catch (e) {
+                            // Suppress EPIPE errors during write
+                        }
+                    }
+                }
+            };
+        } catch (error) {
+            console.error('Streaming audit results error:', error.message);
+            process.stdin.resume();
+            return null;
+        }
+    }
+
     showNoItems(itemType) {
         try {
             spawnSync(this._binaryPath, ['no-items', '--type', itemType], {
                 stdio: 'inherit'
             });
         } catch (error) {
-            console.error('No items error:', error);
+            console.error('UI No Items error:', error.message);
         }
     }
 
@@ -321,29 +383,32 @@ class GoUISession {
             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}`);
+        throw new Error(`Critical: TNG UI binary not found at ${localBinary}. Please reinstall the extension.`);
     }
 
     _createTempFile(prefix, suffix) {
         const tmpDir = os.tmpdir();
-        const filePath = path.join(tmpDir, `${prefix}-${Date.now()}-${Math.floor(Math.random() * 1000)}${suffix}`);
+        const filePath = path.join(tmpDir, `tng-${prefix}-${Date.now()}-${Math.floor(Math.random() * 1000)}${suffix}`);
         fs.writeFileSync(filePath, '');
         return filePath;
     }
 
+    _trackTempFile(filePath) {
+        this._tempFiles.add(filePath);
+        return filePath;
+    }
+
     _cleanupTempFile(filePath) {
         if (fs.existsSync(filePath)) {
             try {
                 fs.unlinkSync(filePath);
-            } catch (e) {
-                // Ignore cleanup errors
-            }
+                this._tempFiles.delete(filePath);
+            } catch (e) { }
         }
     }
 }

package/lib/jsonSession.js

@@ -14,21 +14,21 @@ class JsonSession {
     }
 
     displayError(message) {
-        this.emitEvent('error', { message: this.stripColors(message) });
+        this.emitEvent('error', { message: this.stripColors(message || 'Unknown error') });
     }
 
     displayWarning(message) {
-        this.emitEvent('warning', { message: this.stripColors(message) });
+        this.emitEvent('warning', { message: this.stripColors(message || 'Warning') });
     }
 
     displayInfo(message) {
-        this.emitEvent('info', { message: this.stripColors(message) });
+        this.emitEvent('info', { message: this.stripColors(message || '') });
     }
 
     displayList(title, items) {
         this.emitEvent('list', {
-            title: this.stripColors(title),
-            items: items
+            title: this.stripColors(title || 'Items'),
+            items: items || []
         });
     }
 
@@ -37,7 +37,7 @@ class JsonSession {
     }
 
     showProgress(title, callback) {
-        this.emitEvent('progress_start', { title });
+        this.emitEvent('progress_start', { title: title || 'Processing' });
 
         const reporter = new JsonProgressReporter();
 
@@ -45,33 +45,35 @@ class JsonSession {
             const result = callback(reporter);
 
             if (result && result.error) {
-                // Error handled by reporter or caller
+                // Keep progress state but report error
+                this.emitEvent('error', { message: result.error });
             } else {
                 this.emitEvent('progress_complete', {
                     message: result?.message || 'Done',
-                    result: result
+                    result: result || {}
                 });
             }
 
             return result;
         } catch (error) {
-            this.emitEvent('error', { message: error.message });
+            const errMsg = error?.message || 'Progress interrupted by unknown error';
+            this.emitEvent('error', { message: errMsg });
             throw error;
         }
     }
 
     showAuditResults(auditResult) {
-        this.emitEvent('result', auditResult);
+        this.emitEvent('result', auditResult || {});
     }
 
     showTestResults(title, passed, failed, errors, total, results = []) {
         this.emitEvent('test_results', {
-            title,
-            passed,
-            failed,
-            errors,
-            total,
-            results
+            title: title || 'Test Results',
+            passed: Math.max(0, passed || 0),
+            failed: Math.max(0, failed || 0),
+            errors: Math.max(0, errors || 0),
+            total: Math.max(0, total || 0),
+            results: results || []
         });
     }
 
@@ -80,29 +82,35 @@ class JsonSession {
     }
 
     showConfigError(missing) {
-        this.emitEvent('config_error', { missing });
+        this.emitEvent('config_error', { missing: missing || [] });
     }
 
     showConfigMissing(missingItems) {
-        this.emitEvent('config_missing', { missing: missingItems });
+        this.emitEvent('config_missing', { missing: missingItems || [] });
     }
 
     showSystemStatus(status) {
-        this.emitEvent('system_status', status);
+        this.emitEvent('system_status', status || {});
     }
 
     showNoItems(type) {
-        this.emitEvent('no_items', { type });
+        this.emitEvent('no_items', { type: type || 'items' });
     }
 
     stripColors(str) {
+        if (typeof str !== 'string') return '';
         // Remove ANSI color codes
         return str.replace(/\x1b\[\d+(;\d+)*m/g, '');
     }
 
     emitEvent(type, data = {}) {
-        const event = { type, ...data };
-        console.log(JSON.stringify(event));
+        try {
+            const event = { type, ...data, timestamp: Date.now() };
+            console.log(JSON.stringify(event));
+        } catch (e) {
+            // If serialization fails (e.g. circular ref), emit minimal error
+            console.log(JSON.stringify({ type: 'error', message: 'Internal session serialization error' }));
+        }
     }
 }
 
@@ -115,17 +123,29 @@ class JsonProgressReporter {
         const { stepIncrement = true, explicitStep = null } = options;
         const stepIdx = explicitStep !== null ? explicitStep : this.step;
 
-        const payload = {
+        let payload = {
             type: 'progress_update',
-            message,
             step: stepIdx
         };
 
+        if (typeof message === 'string' && message.trim().startsWith('{')) {
+            try {
+                const parsed = JSON.parse(message);
+                payload = { ...payload, ...parsed };
+            } catch (e) {
+                payload.message = message;
+            }
+        } else {
+            payload.message = message || '';
+        }
+
         if (percent !== null) {
-            payload.percent = percent;
+            payload.percent = Math.min(100, Math.max(0, percent));
         }
 
-        console.log(JSON.stringify(payload));
+        try {
+            console.log(JSON.stringify(payload));
+        } catch (e) { }
 
         if (stepIncrement && explicitStep === null) {
             this.step += 1;
@@ -133,7 +153,9 @@ class JsonProgressReporter {
     }
 
     error(message) {
-        console.log(JSON.stringify({ type: 'error', message }));
+        try {
+            console.log(JSON.stringify({ type: 'error', message: message || 'Unknown error' }));
+        } catch (e) { }
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tng-sh/js",
-    "version": "0.0.8",
+    "version": "0.1.0",
     "description": "TNG JavaScript CLI",
     "repository": {
         "type": "git",