@tng-sh/js 0.1.0 → 0.1.2

package/bin/tng.js

@@ -7,6 +7,7 @@ const path = require('path');
 const { loadConfig } = require('../lib/config');
 const { saveTestFile } = require('../lib/saveFile');
 const { ping, getUserStats } = require('../index');
+const { applyFix } = require('../lib/fixApplier');
 
 // Handle EPIPE errors gracefully when child process (Go UI) exits
 process.stdout.on('error', (err) => {
@@ -27,7 +28,7 @@ process.on('uncaughtException', (err) => {
 program
     .name('tng')
     .description('TNG - Automated Test Generation, and audit generation for JavaScript')
-    .version('0.1.0');
+    .version('0.1.2');
 
 /**
  * @command init
@@ -142,6 +143,65 @@ program
         launchInteractive();
     });
 
+/**
+ * @command xray
+ * Generate X-Ray (Mermaid Visualization)
+ */
+program
+    .command('xray')
+    .alias('x')
+    .description('Generate X-Ray visualization')
+    .option('-f, --file <path>', 'Input file path')
+    .option('-m, --method <name>', 'Method name to visualize')
+    .action(async (options) => {
+        if (!options.file || !options.method) {
+            console.log(chalk.red('Error: Both --file and --method are required for X-Ray.'));
+            console.log(chalk.yellow('Usage: tng xray -f <file> -m <method>'));
+            process.exit(1);
+        }
+
+        console.log(chalk.blue(`🔍 Generating X-Ray for ${options.method} in ${options.file}...`));
+
+        try {
+            const config = loadConfig();
+
+            // Re-use logic similar to _handleXrayFlow but tailored for CLI non-interactive output
+            const { generateTest } = require('../index');
+
+            // We use a custom callback to show progress
+            const callback = (msg, percent) => {
+                if (percent % 20 === 0) console.log(chalk.dim(`[${percent}%] ${msg}`));
+            };
+
+            // We pass 'visualize' as the test type
+            const resultJson = generateTest(
+                path.resolve(options.file),
+                options.method,
+                null,
+                'visualize',
+                JSON.stringify(config),
+                callback
+            );
+
+            let mermaidCode = "";
+            try {
+                const parsed = JSON.parse(resultJson);
+                mermaidCode = parsed.mermaid_code || resultJson;
+            } catch (e) {
+                mermaidCode = resultJson;
+            }
+
+            console.log(chalk.bold('\n--- X-Ray Result (Mermaid.js) ---\n'));
+            console.log(chalk.blue(mermaidCode));
+            console.log(chalk.bold('\n---------------------------------\n'));
+            console.log(chalk.green('✓ Copy the code above and paste into https://mermaid.live'));
+
+        } catch (e) {
+            console.log(chalk.red(`Error: ${e.message}`));
+            process.exit(1);
+        }
+    });
+
 /**
  * Main command handler (handles -f and -m)
  */
@@ -166,6 +226,39 @@ program
         }
     });
 
+/**
+ * @command fix
+ * Apply a specific fix to a file
+ */
+program
+    .command('fix')
+    .description('Apply a fix to a file')
+    .option('-f, --file <path>', 'File path to fix')
+    .option('-d, --data <json>', 'JSON data for the audit item containing fix info')
+    .action(async (options) => {
+        if (!options.file || !options.data) {
+            console.log(chalk.red('Error: Both --file and --data are required.'));
+            process.exit(1);
+        }
+
+        try {
+            const item = JSON.parse(options.data);
+            const result = await applyFix(options.file, item);
+            if (result.success) {
+                console.log(chalk.green(`✓ Fix applied to ${options.file}`));
+                if (result.backup_path) {
+                    console.log(chalk.dim(`  Backup created at ${result.backup_path}`));
+                }
+            } else {
+                console.log(chalk.red(`❌ Failed to apply fix: ${result.error}`));
+                process.exit(1);
+            }
+        } catch (e) {
+            console.log(chalk.red(`Error: ${e.message}`));
+            process.exit(1);
+        }
+    });
+
 
 
 /**

package/index.d.ts

@@ -29,6 +29,16 @@ export declare function getUserStats(baseUrl: string, apiKey: string): string
  * 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
+/**
+ * Applies a single edit operation to a file.
+ * Uses backup and atomic write for safety.
+ */
+export declare function applyEdit(filePath: string, search: string, replace: string, lineHint?: number | undefined | null): string
+/**
+ * Applies multiple edit operations atomically.
+ * All succeed or all fail (with rollback).
+ */
+export declare function applyEditsAtomic(operationsJson: string): string
 /**
  * Orchestrates the test generation process.
  * Analyzes code, submits a job, and polls for the final generated test.

package/index.js

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

package/lib/auditWorker.js

@@ -0,0 +1,28 @@
+const { parentPort, workerData } = require('worker_threads');
+const { runAudit } = require('../index');
+const { loadConfig } = require('./config');
+
+const { filePath, methodName, className, testType } = workerData;
+const config = loadConfig();
+
+try {
+    const resultJson = runAudit(
+        filePath,
+        methodName,
+        className,
+        testType,
+        JSON.stringify(config),
+        (msg) => {
+            if (parentPort) {
+                parentPort.postMessage({ type: 'item', data: msg });
+            }
+        }
+    );
+    if (parentPort) {
+        parentPort.postMessage({ type: 'result', data: resultJson });
+    }
+} catch (e) {
+    if (parentPort) {
+        parentPort.postMessage({ type: 'error', data: e.message });
+    }
+}

package/lib/config.js

@@ -21,6 +21,7 @@ const loadConfig = () => {
 
         return Object.keys(filtered).length > 0 ? filtered : config;
     } catch (error) {
+        console.error(`Failed to load config from ${configFile}:`, error.message);
         return {};
     }
 };

package/lib/fixApplier.js

@@ -0,0 +1,59 @@
+const { applyEdit } = require('../index');
+
+/**
+ * Parses a SEARCH_AND_REPLACE block from a string
+ * @param {string} codeChange
+ * @returns {{search: string, replace: string} | null}
+ */
+function parseSearchReplace(codeChange) {
+    if (!codeChange) return null;
+
+    // Try to find SEARCH: and REPLACE: blocks
+    const searchIdx = codeChange.indexOf('SEARCH:');
+    const replaceIdx = codeChange.indexOf('REPLACE:');
+
+    if (searchIdx !== -1 && replaceIdx !== -1 && searchIdx < replaceIdx) {
+        const search = codeChange.substring(searchIdx + 7, replaceIdx).trim();
+        const replace = codeChange.substring(replaceIdx + 8).trim();
+        return { search, replace };
+    }
+
+    return null;
+}
+
+/**
+ * Appies a fix to a file
+ * @param {string} filePath
+ * @param {object} item
+ * @returns {object} result
+ */
+async function applyFix(filePath, item) {
+    try {
+        if (!item) {
+            return { success: false, error: 'Item is null or undefined' };
+        }
+        const codeChange = item.fix_code_change || (item.fix && item.fix.how && item.fix.how.code_change);
+        if (!codeChange) {
+            return { success: false, error: 'No code change found in fix data' };
+        }
+
+        const parsed = parseSearchReplace(codeChange);
+        if (!parsed) {
+            return { success: false, error: 'Failed to parse SEARCH_AND_REPLACE block' };
+        }
+
+        const resultJson = applyEdit(
+            filePath,
+            parsed.search,
+            parsed.replace,
+            typeof item.line_number === 'number' && item.line_number > 0 ? item.line_number : null
+        );
+
+        const result = JSON.parse(resultJson);
+        return result;
+    } catch (e) {
+        return { success: false, error: e.message };
+    }
+}
+
+module.exports = { applyFix, parseSearchReplace };

package/lib/generateTestsUi.js

@@ -1,10 +1,12 @@
+const fs = require('fs');
 const path = require('path');
 const glob = require('fast-glob');
 const chalk = require('chalk');
 const GoUISession = require('./goUiSession');
-const { getFileOutline, runAudit, generateTest, 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) {
@@ -32,6 +34,9 @@ class GenerateTestsUI {
             } else if (choice === 'audit') {
                 const result = await this._showFileSelection(true);
                 if (result === 'exit') return 'exit';
+            } else if (choice === 'xray') {
+                const result = await this._showFileSelection(false, true);
+                if (result === 'exit') return 'exit';
             } else if (choice === 'stats') {
                 await this._showStats();
             } else if (choice === 'about') {
@@ -93,7 +98,7 @@ class GenerateTestsUI {
         });
     }
 
-    async _showFileSelection(isAudit = false) {
+    async _showFileSelection(isAudit = false, isXray = false) {
         const files = await this._getUserFiles();
 
         if (files.length === 0) {
@@ -107,19 +112,19 @@ class GenerateTestsUI {
             path: path.dirname(file)
         }));
 
-        const title = isAudit ? 'Select JavaScript File to Audit' : 'Select JavaScript File';
+        const title = isXray ? 'Select File for X-Ray' : (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);
+        const result = await this._showMethodsForFile(selectedFile, isAudit, isXray);
         if (result === 'main_menu') return 'main_menu';
         return result;
     }
 
-    async _showMethodsForFile(filePath, isAudit = false) {
+    async _showMethodsForFile(filePath, isAudit = false, isXray = false) {
         let outline;
         try {
             const result = getFileOutline(filePath);
@@ -142,33 +147,39 @@ class GenerateTestsUI {
             methodData: m
         }));
 
-        const title = isAudit ? `Select Method to Audit for ${fileName}` : `Select Method for ${fileName}`;
+        const title = isXray ? `Select Method to X-Ray for ${fileName}` : (isAudit ? `Select Method to Audit for ${fileName}` : `Select Method for ${fileName}`);
         const selectedDisplay = this.goUiSession.showListView(title, items);
 
-        if (selectedDisplay === 'back' || !selectedDisplay) return this._showFileSelection(isAudit);
+        if (selectedDisplay === 'back' || !selectedDisplay) return this._showFileSelection(isAudit, isXray);
 
         const selectedMethod = items.find(i => i.name === selectedDisplay)?.methodData;
 
         if (selectedMethod) {
+            if (isXray) {
+                const choice = await this._generateTestsForMethod(filePath, selectedMethod, 'visualize', false, true);
+                if (choice === 'main_menu') return 'main_menu';
+                return this._showFileSelection(isAudit, isXray);
+            }
+
             const testType = this.goUiSession.showJsTestMenu();
-            if (testType === 'back') return this._showFileSelection(isAudit);
+            if (testType === 'back') return this._showFileSelection(isAudit, isXray);
 
             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);
+                return this._showFileSelection(isAudit, isXray);
             }
 
             if (choice && choice.file_path && !choice.error) {
                 this._showPostGenerationMenu(choice);
             }
         }
-        return this._showFileSelection(isAudit);
+        return this._showFileSelection(isAudit, isXray);
     }
 
-    async _generateTestsForMethod(filePath, method, testType, isAudit = false) {
+    async _generateTestsForMethod(filePath, method, testType, isAudit = false, isXray = false) {
         if (!this._hasApiKey()) {
             return { error: 'No API key' };
         }
@@ -177,6 +188,10 @@ class GenerateTestsUI {
             return this._handleAuditFlow(filePath, method, testType);
         }
 
+        if (isXray) {
+            return this._handleXrayFlow(filePath, method);
+        }
+
         const fileName = path.basename(filePath);
         const displayName = method.class_name ? `${method.class_name}#${method.name}` : `${fileName}#${method.name}`;
         return this._handleTestGenerationFlow(filePath, method, testType, displayName);
@@ -193,7 +208,7 @@ class GenerateTestsUI {
     }
 
     async _handleAuditFlow(filePath, method, testType) {
-        const config = loadConfig();
+        const { Worker } = require('worker_threads');
         const streamingUi = await this.goUiSession.showStreamingAuditResults(
             method.name,
             method.class_name,
@@ -202,25 +217,158 @@ class GenerateTestsUI {
 
         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;
+
+        // 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 }
+        });
+
+        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;
+                        });
+                    };
+
+                    results.issues = mergeList(results.issues, finalResults.issues || finalResults.findings);
+                    results.behaviours = mergeList(results.behaviours, finalResults.behaviours);
+
+                    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;
+            }
+        });
+
+        worker.on('error', (err) => {
+            console.error(chalk.red(`Worker error: ${err.message}`));
+            auditFinished = true;
+        });
+
         try {
-            const resultJson = runAudit(
-                filePath,
-                method.name,
-                method.class_name || null,
-                testType || null,
-                JSON.stringify(config),
-                (msg) => {
-                    if (msg.startsWith('{')) {
-                        streamingUi.write(msg);
+            let currentChoice = null;
+
+            // Wait for INITIAL streaming session to complete (user picks an action or quits)
+            await streamingUi.wait;
+
+            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) {
+                            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);
+                }
 
-            await streamingUi.wait;
-            return { message: 'Audit complete', 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');
+                }
+
+                // 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 };
+                    }
+                }
+            }
+
+            return { message: 'Audit complete', results };
         } catch (e) {
-            console.error(chalk.red(`\nAudit failed: ${e.message}\n`));
+            console.error(chalk.red(`\nAudit flow failed: ${e.message}\n`));
             return null;
+        } finally {
+            await worker.terminate();
         }
     }
 
@@ -260,6 +408,78 @@ class GenerateTestsUI {
         return uiResult || null;
     }
 
+    async _handleXrayFlow(filePath, method) {
+        const actionName = 'Generating X-Ray for';
+        const displayName = method.name;
+
+        const progressHandler = async (progress) => {
+            progress.update('Analyzing method structure...');
+
+            try {
+                const config = loadConfig();
+                // Override test_type to 'visualize' which behaves like test generation but returns Mermaid code
+                const resultJson = generateTest(
+                    filePath,
+                    method.name,
+                    method.class_name || null,
+                    'visualize',
+                    JSON.stringify(config),
+                    (msg, percent) => {
+                        // Simple progress updates
+                        progress.update(msg, { percent });
+                    }
+                );
+
+                // The result is expected to be a JSON string containing the mermaid definition
+                // But generateTest returns the full file content usually.
+                // We need to clarify if Backend returns just Mermaid or a file.
+                // Assuming Backend returns JSON with { "visualize_result": "mermaid code..." } or similar
+                // or if it returns raw text, we handle it.
+
+                // For 'visualize' type, existing backend generates a file or JSON.
+                // We should parse it.
+                let mermaidCode = "";
+                try {
+                    const parsed = JSON.parse(resultJson);
+                    if (parsed.mermaid_code) mermaidCode = parsed.mermaid_code;
+                    else mermaidCode = resultJson; // Fallback
+                } catch (e) {
+                    mermaidCode = resultJson;
+                }
+
+                return {
+                    success: true,
+                    mermaidCode: mermaidCode
+                };
+            } catch (e) {
+                progress.error(`Failed to generate X-Ray: ${e.message}`);
+                return { error: e.message };
+            }
+        };
+
+        const result = await this.goUiSession.showProgress(`${actionName} ${displayName}`, progressHandler);
+
+        if (result && result.mermaidCode) {
+            console.log(chalk.bold('\n--- X-Ray Result (Mermaid.js) ---\n'));
+            // Simple highlighting for terminal
+            console.log(chalk.blue(result.mermaidCode));
+            console.log(chalk.bold('\n---------------------------------\n'));
+
+            // Prompt user action
+            this._copyToClipboard(result.mermaidCode);
+            console.log(chalk.green('✓ Copied to clipboard! Paste into https://mermaid.live'));
+
+            // Wait for user confirmation to return
+            const { execSync } = require('child_process');
+            try {
+                // Just a pause hack if we want, but showListView might be better.
+                // For now, let's just return.
+            } catch (e) { }
+        }
+
+        return result;
+    }
+
     _updateProgress(progress, msg, percent) {
         const agentMap = {
             'context_agent_status': { label: 'Context Builder', step: 1 },
@@ -394,6 +614,26 @@ class GenerateTestsUI {
         }
     }
 
+    _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) {
+            console.log(chalk.yellow(`\n⚠️ Failed to open editor: ${e.message}`));
+        }
+    }
+
     async _getUserFiles() {
         const patterns = ['**/*.{js,ts,jsx,tsx}'];
         const ignore = [

package/lib/goUiSession.js

@@ -268,8 +268,7 @@ class GoUISession {
             console.error('Test results display error:', error.message);
         }
     }
-
-    async showAuditResults(auditResult) {
+    async showAuditResults(auditResult, index = 0) {
         const dataJson = JSON.stringify(auditResult);
         const inputFile = this._trackTempFile(this._createTempFile('audit-data', '.json'));
         const outputFile = this._trackTempFile(this._createTempFile('audit-choice', '.txt'));
@@ -283,7 +282,12 @@ class GoUISession {
             process.stdin.pause();
 
             await new Promise((resolve, reject) => {
-                const child = spawn(this._binaryPath, ['audit-results', '--file', inputFile, '--output', outputFile], {
+                const args = ['audit-results', '--file', inputFile, '--output', outputFile];
+                if (index > 0) {
+                    args.push('--index', index.toString());
+                }
+
+                const child = spawn(this._binaryPath, args, {
                     stdio: ['inherit', 'inherit', 'inherit'],
                     env: process.env
                 });

package/package.json

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