@tng-sh/js 0.1.0 → 0.1.1

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.1');
 
 /**
  * @command init
@@ -166,6 +167,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) {
@@ -193,7 +195,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 +204,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();
         }
     }
 
@@ -394,6 +529,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.1",
     "description": "TNG JavaScript CLI",
     "repository": {
         "type": "git",