@tng-sh/js 0.1.9 → 0.2.1

package/.idea/js-pie.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="RUBY_MODULE" version="4">
+  <component name="ModuleRunConfigurationManager">
+    <shared />
+  </component>
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

package/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/js-pie.iml" filepath="$PROJECT_DIR$/.idea/js-pie.iml" />
+    </modules>
+  </component>
+</project>

package/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

package/bin/tng.js

@@ -28,7 +28,7 @@ process.on('uncaughtException', (err) => {
 program
     .name('tng')
     .description('TNG - Advanced Code Audit, Test Generation, Visualization, Clone Detection, and Dead Code Analysis for JavaScript/TypeScript')
-    .version('0.1.9');
+    .version('0.2.1');
 
 /**
  * Copy text to system clipboard
@@ -253,7 +253,9 @@ program
     .option('-c, --clones', 'Run duplicate code detection')
     .option('-l, --level <level>', 'Set clone detection level (1: token, 2: structural, 3: fuzzy, or all)', 'all')
     .option('-d, --deadcode', 'Run dead code detection (JS/TS/React)')
+    .option('--all', 'Run dead code detection across the entire repo (respects .gitignore)')
     .option('--xray', 'Generate X-Ray visualization (Mermaid flowchart)')
+    .option('--impact', 'Run impact analysis (blast radius check) on a method')
     .option('--json', 'Output results as JSON events (machine-readable)')
 
     .action(async (options) => {
@@ -284,7 +286,7 @@ program
                     const binaryPath = session._binaryPath;
 
                     const { spawnSync } = require('child_process');
-                    spawnSync(binaryPath, ['trace-results', '--file', tmpFile], {
+                    spawnSync(binaryPath, ['js-trace-results', '--file', tmpFile], {
                         stdio: 'inherit'
                     });
 
@@ -344,6 +346,12 @@ program
                 return;
             }
 
+
+            if (options.impact) {
+                await runImpact(options.file, options.method, options.json);
+                return;
+            }
+
             if (!options.type && !options.audit) {
                 console.log(chalk.red('Error: --type <type> is required.'));
                 process.exit(1);
@@ -353,11 +361,32 @@ program
             if (options.clones) {
                 await runClones(options.file, options.level || 'all', options.json);
             } else if (options.deadcode) {
-                await runDeadCode(options.file, options.json);
+                if (options.all) {
+                    await runDeadCodeRepo(options.json);
+                } else {
+                    await runDeadCode(options.file, options.json);
+                }
             } else {
                 console.log(chalk.yellow('Specify a method with -m, use --outline to see methods, or run "tng i" for full selection.'));
             }
-        } else if (!options.file && !options.method && process.argv.length <= 2) {
+            if (options.xray) {
+                // ... (existing xray logic) ...
+                return;
+            }
+
+            if (options.impact) {
+                await runImpact(options.file, options.method, options.json);
+                return;
+            }
+
+            if (!options.type && !options.audit) {
+                console.log(chalk.red('Error: --type <type> is required.'));
+                process.exit(1);
+            }
+            generateTest(options.file, options.method, options.type, options.audit, options.json);
+        } else if (options.deadcode && options.all && !options.file && !options.method) {
+            await runDeadCodeRepo(options.json);
+        } else if (options.file && !options.method) {
             launchInteractive();
         }
     });
@@ -439,7 +468,7 @@ async function runDeadCode(filePath, jsonMode = false) {
         jsonSession.start();
         try {
             const resultJson = detectDeadCode(absolutePath);
-            jsonSession.emitEvent('dead_code', JSON.parse(resultJson));
+            jsonSession.showDeadCode(JSON.parse(resultJson));
             jsonSession.stop();
         } catch (e) {
             jsonSession.displayError(e.message);
@@ -469,6 +498,144 @@ async function runDeadCode(filePath, jsonMode = false) {
     }
 }
 
+function listDeadCodeFiles(projectRoot) {
+    const { listDeadcodeFiles } = require('../index');
+    try {
+        const filesJson = listDeadcodeFiles(projectRoot);
+        const files = JSON.parse(filesJson);
+        if (!Array.isArray(files)) return [];
+        return files.filter((f) => !f.endsWith('.d.ts'));
+    } catch (e) {
+        return [];
+    }
+}
+
+async function runDeadCodeRepo(jsonMode = false) {
+    const { detectDeadCode } = require('../index');
+    const projectRoot = process.cwd();
+    const files = listDeadCodeFiles(projectRoot);
+
+    if (files.length === 0) {
+        console.log(chalk.yellow('No files found for dead code analysis.'));
+        return;
+    }
+
+    const runAnalysis = async () => {
+        const aggregateIssues = [];
+        for (let i = 0; i < files.length; i++) {
+            const filePath = files[i];
+            const rel = path.relative(projectRoot, filePath);
+            try {
+                const resultJson = detectDeadCode(filePath);
+                const issues = JSON.parse(resultJson);
+                if (Array.isArray(issues)) {
+                    for (const issue of issues) {
+                        aggregateIssues.push({
+                            issue_type: issue.issue_type,
+                            line: issue.line,
+                            message: `[${rel}] ${issue.message}`,
+                            code_snippet: issue.code_snippet,
+                            file: rel
+                        });
+                    }
+                }
+            } catch (e) {
+                aggregateIssues.push({
+                    issue_type: 'analysis_error',
+                    line: 0,
+                    message: `[${rel}] Failed to analyze: ${e.message}`,
+                    code_snippet: '',
+                    file: rel
+                });
+            }
+        }
+        return aggregateIssues;
+    };
+
+    if (jsonMode) {
+        const { JsonSession } = require('../lib/jsonSession');
+        const jsonSession = new JsonSession();
+        jsonSession.start();
+        const issues = await runAnalysis();
+        const out = {
+            file: projectRoot,
+            dead_code: issues.map(i => ({
+                type: i.issue_type,
+                line: i.line,
+                message: i.message,
+                code: i.code_snippet,
+                file: i.file
+            }))
+        };
+        jsonSession.showDeadCode(out);
+        jsonSession.stop();
+        return;
+    }
+
+    const total = files.length;
+    const aggregateIssues = [];
+    const start = Date.now();
+
+    const renderBar = (current, totalCount) => {
+        const width = 20;
+        const ratio = totalCount === 0 ? 1 : current / totalCount;
+        const filled = Math.round(ratio * width);
+        const bar = '#'.repeat(filled) + '-'.repeat(width - filled);
+        const percent = Math.round(ratio * 100);
+        return `Scanning project... [${bar}] ${percent}%`;
+    };
+
+    process.stdout.write(renderBar(0, total));
+    for (let i = 0; i < files.length; i++) {
+        const filePath = files[i];
+        const rel = path.relative(projectRoot, filePath);
+        try {
+            const resultJson = detectDeadCode(filePath);
+            const issues = JSON.parse(resultJson);
+            if (Array.isArray(issues)) {
+                for (const issue of issues) {
+                    aggregateIssues.push({
+                        file: rel,
+                        line: issue.line,
+                        message: issue.message,
+                        code_snippet: issue.code_snippet,
+                        issue_type: issue.issue_type
+                    });
+                }
+            }
+        } catch (e) {
+            aggregateIssues.push({
+                file: rel,
+                line: 0,
+                message: `Failed to analyze: ${e.message}`,
+                code_snippet: '',
+                issue_type: 'analysis_error'
+            });
+        }
+
+        if (i % 10 === 0 || i === total - 1) {
+            process.stdout.write('\r' + renderBar(i + 1, total));
+        }
+    }
+    process.stdout.write('\n');
+
+    if (aggregateIssues.length === 0) {
+        console.log('No dead code detected.');
+        const seconds = ((Date.now() - start) / 1000).toFixed(2);
+        console.log(`Summary: Found 0 dead items in ${seconds}s.`);
+        return;
+    }
+
+    console.log('Found dead code:');
+    for (const issue of aggregateIssues) {
+        const snippet = issue.code_snippet ? ` (${issue.code_snippet.trim()})` : '';
+        console.log(`- ${issue.file}:${issue.line}${snippet}`);
+    }
+    const seconds = ((Date.now() - start) / 1000).toFixed(2);
+    console.log(`Summary: Found ${aggregateIssues.length} dead items in ${seconds}s.`);
+    console.log("[Tip] Run 'tng audit' to fix logic bugs in the remaining code.");
+}
+
 /**
  * @command fix
  * Apply a specific fix to a file
@@ -611,17 +778,20 @@ async function generateTest(filePath, methodName, testType, auditMode = false, j
                 if (saved) {
                     jsonSession.emitEvent('test_saved', {
                         file_path: saved.file_path,
+                        absolute_path: saved.absolute_path,
                         message: `Test saved to: ${saved.file_path}`
                     });
                 } else {
-                    jsonSession.displayError('Failed to save test file');
+                    const details = saveTestFile.lastError ? `: ${saveTestFile.lastError}` : '';
+                    jsonSession.displayError(`Failed to save test file${details}`);
                 }
                 jsonSession.stop();
             } else {
                 if (saved) {
                     console.log(chalk.green(`✓ Test saved to: ${saved.file_path}`));
                 } else {
-                    console.log(chalk.yellow('Failed to save test file'));
+                    const details = saveTestFile.lastError ? `: ${saveTestFile.lastError}` : '';
+                    console.log(chalk.yellow(`Failed to save test file${details}`));
                 }
             }
         }
@@ -651,4 +821,76 @@ program.on('--help', () => {
     console.log('');
 });
 
+/**
+ * Logic to run impact analysis
+ */
+async function runImpact(filePath, methodName, jsonMode = false) {
+    const { analyzeImpact } = require('../index');
+    const absolutePath = path.resolve(filePath);
+    const projectRoot = process.cwd();
+
+    if (!fs.existsSync(absolutePath)) {
+        console.log(chalk.red(`File not found: ${filePath}`));
+        process.exit(1);
+    }
+
+    if (jsonMode) {
+        try {
+            const resultJson = analyzeImpact(projectRoot, absolutePath, methodName);
+            console.log(resultJson);
+        } catch (e) {
+            console.error(JSON.stringify({ error: e.message }));
+            process.exit(1);
+        }
+        return;
+    }
+
+    console.log(chalk.blue(`💥 Analyzing impact for ${methodName} in ${filePath}...`));
+
+    try {
+        const resultJson = analyzeImpact(projectRoot, absolutePath, methodName);
+        const result = JSON.parse(resultJson);
+
+        if (result.status === 'error') {
+            console.log(chalk.red(`\nError: ${result.diffs[0].message}`));
+            return;
+        }
+
+        console.log(chalk.bold(`\nStatus: `) + (result.status === 'breaking' ? chalk.red.bold('BREAKING CHANGES DETECTED') : result.status === 'warning' ? chalk.yellow.bold('WARNINGS FOUND') : chalk.green.bold('SAFE')));
+
+        if (result.diffs.length > 0) {
+            console.log(chalk.bold('\nChanges:'));
+            result.diffs.forEach(diff => {
+                const color = diff.severity === 'breaking' ? chalk.red : (diff.severity === 'warning' ? chalk.yellow : chalk.white);
+                const icon = diff.severity === 'breaking' ? '❌' : (diff.severity === 'warning' ? '⚠️' : 'ℹ️');
+                // Handle optional name
+                const nameStr = diff.name ? ` (${diff.name})` : '';
+                console.log(`  ${icon} ${color(diff.message)}${color(nameStr)}`);
+            });
+        } else {
+             console.log(chalk.green('  No changes detected in logic signature.'));
+        }
+
+        if (result.impacted_files.length > 0) {
+            console.log(chalk.bold(`\nImpacted Files (${result.impacted_files.length}):`));
+            result.impacted_files.forEach(f => {
+                // Relativize path
+                const relPath = path.relative(projectRoot, f.file);
+                console.log(chalk.dim(`  • ${relPath}:${f.line}`));
+                // simple truncate code
+                const codePreview = f.code.trim().replace(/\n/g, ' ').substring(0, 60) + (f.code.length > 60 ? '...' : '');
+                console.log(chalk.gray(`    ${codePreview}`));
+            });
+        } else if (result.status === 'breaking') {
+            console.log(chalk.green('\nNo call sites found in this project. You might be safe!'));
+        }
+
+    } catch (e) {
+        console.log(chalk.red(`Analysis failed: ${e.message}`));
+        if (e.message.includes("git")) {
+             console.log(chalk.yellow("Note: Impact analysis requires the file to be committed to git."));
+        }
+    }
+}
+
 program.parse(process.argv);

package/index.d.ts

@@ -63,3 +63,10 @@ export declare function getSymbolicTrace(filePath: string, methodName: string, c
 export declare function analyzeClones(projectRoot: string, filePath: string, level: string): string
 /** Analyzes a file for dead code. */
 export declare function detectDeadCode(filePath: string): string
+/** List repo files for dead code analysis (gitignore-aware). */
+export declare function listDeadcodeFiles(projectRoot: string): string
+/**
+ * Analyzes the impact of changes in a specific method compared to git HEAD.
+ * Returns a JSON string containing breaking changes and impacted files.
+ */
+export declare function analyzeImpact(projectRoot: string, filePath: string, methodName: string): 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, runAudit, applyEdit, applyEditsAtomic, generateTest, getSymbolicTrace, analyzeClones, detectDeadCode } = nativeBinding
+const { getFileOutline, getProjectMetadata, findCallSites, ping, submitJob, getUserStats, runAudit, applyEdit, applyEditsAtomic, generateTest, getSymbolicTrace, analyzeClones, detectDeadCode, listDeadcodeFiles, analyzeImpact } = nativeBinding
 
 module.exports.getFileOutline = getFileOutline
 module.exports.getProjectMetadata = getProjectMetadata
@@ -325,3 +325,5 @@ module.exports.generateTest = generateTest
 module.exports.getSymbolicTrace = getSymbolicTrace
 module.exports.analyzeClones = analyzeClones
 module.exports.detectDeadCode = detectDeadCode
+module.exports.listDeadcodeFiles = listDeadcodeFiles
+module.exports.analyzeImpact = analyzeImpact

package/lib/generateTestsUi.js

@@ -34,6 +34,9 @@ class GenerateTestsUI {
             } else if (choice === 'audit') {
                 const result = await this._showFileSelection(true);
                 if (result === 'exit') return 'exit';
+            } else if (choice === 'impact') {
+                const result = await this._showFileSelection(false, false, false, true);
+                if (result === 'exit') return 'exit';
             } else if (choice === 'xray') {
                 const result = await this._showFileSelection(false, true);
                 if (result === 'exit') return 'exit';
@@ -105,9 +108,10 @@ class GenerateTestsUI {
                 return { success: false, message: e.message };
             }
         });
+        return false
     }
 
-    async _showFileSelection(isAudit = false, isXray = false, isTrace = false) {
+    async _showFileSelection(isAudit = false, isXray = false, isTrace = false, isImpact = false) {
         const files = await this._getUserFiles();
 
         if (files.length === 0) {
@@ -123,6 +127,7 @@ class GenerateTestsUI {
 
         let title = 'Select JavaScript File';
         if (isAudit) title = 'Select JavaScript File to Audit';
+        else if (isImpact) title = 'Select JavaScript File to Impact Audit';
         else if (isXray) title = 'Select File for X-Ray';
         else if (isTrace) title = 'Select File for Symbolic Trace';
 
@@ -132,25 +137,25 @@ class GenerateTestsUI {
         if (!selectedName || selectedName === 'exit') return 'exit';
 
         const selectedFile = path.resolve(cwd, selectedName);
-        const result = await this._showMethodsForFile(selectedFile, isAudit, isXray, isTrace);
+        const result = await this._showMethodsForFile(selectedFile, isAudit, isXray, isTrace, isImpact);
         if (result === 'main_menu') return 'main_menu';
         return result;
     }
 
-    async _showMethodsForFile(filePath, isAudit = false, isXray = false, isTrace = false) {
+    async _showMethodsForFile(filePath, isAudit = false, isXray = false, isTrace = false, isImpact = false) {
         let outline;
         try {
             const result = getFileOutline(filePath);
             outline = JSON.parse(result);
         } catch (e) {
             console.error(chalk.red(`\nError parsing file: ${e.message}\n`));
-            return this._showFileSelection(isAudit);
+            return this._showFileSelection(isAudit, isXray, isTrace, isImpact);
         }
 
         const methods = outline.methods || [];
         if (methods.length === 0) {
             this.goUiSession.showNoItems('methods');
-            return this._showFileSelection(isAudit);
+            return this._showFileSelection(isAudit, isXray, isTrace, isImpact);
         }
 
         const fileName = path.basename(filePath);
@@ -162,46 +167,58 @@ class GenerateTestsUI {
 
         let title = 'Select Method';
         if (isAudit) title = `Select Method to Audit for ${fileName}`;
+        else if (isImpact) title = `Select Method to Impact Audit for ${fileName}`;
         else if (isXray) title = `Select Method to X-Ray for ${fileName}`;
         else if (isTrace) title = `Select Method to Trace for ${fileName}`;
 
         const selectedDisplay = this.goUiSession.showListView(title, items);
 
-        if (selectedDisplay === 'back' || !selectedDisplay) return this._showFileSelection(isAudit, isXray, isTrace);
+        if (selectedDisplay === 'back' || !selectedDisplay) return this._showFileSelection(isAudit, isXray, isTrace, isImpact);
 
         const selectedMethod = items.find(i => i.name === selectedDisplay)?.methodData;
 
         if (selectedMethod) {
             if (isTrace) {
                 await this._launchTrace(filePath, selectedMethod.name);
-                return this._showFileSelection(isAudit, isXray, isTrace);
+                return this._showFileSelection(isAudit, isXray, isTrace, isImpact);
             }
 
             if (isXray) {
                 const choice = await this._generateTestsForMethod(filePath, selectedMethod, 'visualize', false, true);
                 if (choice === 'main_menu') return 'main_menu';
-                return this._showFileSelection(isAudit, isXray);
+                return this._showFileSelection(isAudit, isXray, isTrace, isImpact);
             }
 
-            const testType = this.goUiSession.showJsTestMenu();
-            if (testType === 'back') return this._showFileSelection(isAudit, isXray);
-
-            const finalType = testType === 'auto' ? null : testType;
-            const choice = await this._generateTestsForMethod(filePath, selectedMethod, finalType, isAudit);
+            if (isImpact) {
+                const choice = await this._generateTestsForMethod(filePath, selectedMethod, null, false, false, true);
+                if (choice === 'main_menu') return 'main_menu';
+                return this._showFileSelection(isAudit, isXray, isTrace, isImpact);
+            }
 
             if (isAudit) {
+                const choice = await this._generateTestsForMethod(filePath, selectedMethod, null, true);
                 if (choice === 'main_menu') return 'main_menu';
-                return this._showFileSelection(isAudit, isXray);
+                return this._showFileSelection(isAudit, isXray, isTrace, isImpact);
             }
 
+            const testType = this.goUiSession.showJsTestMenu();
+            if (testType === 'back') return this._showFileSelection(isAudit, isXray, isTrace, isImpact);
+
+            const finalType = testType === 'auto' ? null : testType;
+            const choice = await this._generateTestsForMethod(filePath, selectedMethod, finalType, false);
+
             if (choice && choice.file_path && !choice.error) {
                 this._showPostGenerationMenu(choice);
             }
         }
-        return this._showFileSelection(isAudit, isXray);
+        return this._showFileSelection(isAudit, isXray, isTrace, isImpact);
     }
 
-    async _generateTestsForMethod(filePath, method, testType, isAudit = false, isXray = false) {
+    async _generateTestsForMethod(filePath, method, testType, isAudit = false, isXray = false, isImpact = false) {
+        if (isImpact) {
+            return this._handleImpactFlow(filePath, method);
+        }
+
         if (!this._hasApiKey()) {
             return { error: 'No API key' };
         }
@@ -229,169 +246,75 @@ class GenerateTestsUI {
         return true;
     }
 
-    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;
+    async _handleImpactFlow(filePath, method) {
+        const { analyzeImpact } = require('../index');
+        const projectRoot = process.cwd();
 
-        // 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 }
-        });
+        console.log(chalk.blue(`\n🔍 Analyzing impact for ${method.name}...`));
 
-        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;
-            }
-        });
+        let impactResult;
+        try {
+            const resultJson = await this.goUiSession.showProgress('Analyzing impact...', async (progress) => {
+                progress.update('Tracing method versions...', { percent: 30 });
+                // Artificial delay for UX
+                await new Promise(r => setTimeout(r, 300));
 
-        worker.on('error', (err) => {
-            console.error(chalk.red(`Worker error: ${err.message}`));
-            auditFinished = true;
-        });
+                const json = analyzeImpact(projectRoot, filePath, method.name);
+                progress.update('Comparing logic...', { percent: 80 });
+
+                return json;
+            });
 
+            impactResult = JSON.parse(resultJson);
+        } catch (e) {
+            console.error(chalk.red(`\nImpact Analysis failed: ${e.message}\n`));
+            return null;
+        }
+
+        await this.goUiSession.showImpactResults(impactResult);
+        return { message: 'Impact audit complete' };
+    }
+
+    async _handleAuditFlow(filePath, method, testType) {
+        const { runAudit } = require('../index');
+        const config = loadConfig();
+        const fileName = path.basename(filePath);
+        const displayName = method.class_name ? `${method.class_name}#${method.name}` : `${fileName}#${method.name}`;
+
+        console.log(chalk.blue(`\n🔍 Auditing ${displayName}...`));
+
+        let auditResult;
         try {
-            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 };
+            const resultJson = await this.goUiSession.showProgress(`Auditing ${displayName}...`, async (progress) => {
+                progress.update('Preparing audit...', { percent: 10 });
+
+                const json = runAudit(
+                    filePath,
+                    method.name,
+                    method.class_name || null,
+                    testType || null,
+                    JSON.stringify(config),
+                    (msg, percent) => {
+                        if (typeof percent === 'number') {
+                            progress.update(msg, { percent });
+                        } else {
+                            progress.update(msg, { step_increment: false });
                         }
                     }
-                }
-                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);
-                }
-
-                // 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 };
-                    }
-                }
-            }
+                progress.update('Rendering results...', { percent: 95 });
+                return json;
+            });
 
-            return { message: 'Audit complete', results };
+            auditResult = JSON.parse(resultJson);
         } catch (e) {
-            console.error(chalk.red(`\nAudit flow failed: ${e.message}\n`));
+            console.error(chalk.red(`\nAudit failed: ${e.message}\n`));
             return null;
-        } finally {
-            await worker.terminate();
         }
+
+        await this.goUiSession.showAuditResults(auditResult);
+        return { message: 'Audit complete' };
     }
 
     async _handleTestGenerationFlow(filePath, method, testType, displayName) {
@@ -700,7 +623,7 @@ class GenerateTestsUI {
             if (result && result.success && result.file) {
                 // 2. Show Trace UI
                 const { spawnSync } = require('child_process');
-                spawnSync(this.goUiSession._binaryPath, ['trace-results', '--file', result.file], {
+                spawnSync(this.goUiSession._binaryPath, ['js-trace-results', '--file', result.file], {
                     stdio: 'inherit'
                 });
 

package/lib/goUiSession.js

@@ -103,7 +103,18 @@ class GoUISession {
     }
 
     showListView(title, items) {
-        const dataJson = JSON.stringify({ title, items });
+        // Limit items to prevent triggering command line length limits
+        // optimized items (relative paths) allow for more items
+        let displayItems = items;
+        if (items.length > 500) {
+            displayItems = items.slice(0, 500);
+            displayItems.push({
+                name: `... and ${items.length - 500} more files (use CLI for full list)`,
+                path: 'INFO'
+            });
+        }
+
+        const dataJson = JSON.stringify({ title, items: displayItems });
         const outputFile = this._trackTempFile(this._createTempFile('list-view-output', '.txt'));
 
         try {
@@ -308,6 +319,25 @@ class GoUISession {
             console.error('Test results display error:', error.message);
         }
     }
+
+    async showImpactResults(impactResult) {
+        const dataJson = JSON.stringify(impactResult);
+        const inputFile = this._trackTempFile(this._createTempFile('impact-data', '.json'));
+
+        try {
+            fs.writeFileSync(inputFile, dataJson);
+
+            spawnSync(this._binaryPath, ['js-impact-results', '--file', inputFile], {
+                stdio: 'inherit',
+                env: process.env
+            });
+        } catch (error) {
+            console.error('Impact results display error:', error.message);
+        } finally {
+            this._cleanupTempFile(inputFile);
+        }
+    }
+
     async showAuditResults(auditResult, index = 0) {
         const dataJson = JSON.stringify(auditResult);
         const inputFile = this._trackTempFile(this._createTempFile('audit-data', '.json'));
@@ -351,6 +381,7 @@ class GoUISession {
         }
     }
 
+
     async showClones(filePath, results) {
         const dataJson = JSON.stringify({ file_path: filePath, matches: results });
         const inputFile = this._trackTempFile(this._createTempFile('clone-data', '.json'));

package/lib/jsonSession.js

@@ -74,6 +74,10 @@ class JsonSession {
         this.emitEvent('clones', { file_path: filePath, matches: results });
     }
 
+    showDeadCode(result) {
+        this.emitEvent('dead_code', result || {});
+    }
+
     showTestResults(title, passed, failed, errors, total, results = []) {
         this.emitEvent('test_results', {
             title: title || 'Test Results',

package/lib/saveFile.js

@@ -4,6 +4,7 @@ const chalk = require('chalk');
 const prettier = require('prettier');
 
 const saveTestFile = async (testContent) => {
+    saveTestFile.lastError = null;
     try {
         const parsed = typeof testContent === 'string' ? JSON.parse(testContent) : testContent;
 
@@ -31,6 +32,14 @@ const saveTestFile = async (testContent) => {
             return null;
         }
 
+        // Quick sanity check for likely truncation (common when API cuts the response)
+        const trimmedContent = contentStr.trim();
+        if (trimmedContent.includes('describe(') && !/}\);\s*$/.test(trimmedContent)) {
+            const msg = 'Generated test content appears truncated (missing closing `});`)';
+            console.log(chalk.red.bold(`❌ ${msg}`));
+            return null;
+        }
+
         // Resolve file path
         let filePath = metaSource.test_file_path || metaSource.file_path || metaSource.file_name || metaSource.file ||
             parsed.test_file_path || parsed.file_path || 'generated_test.js';
@@ -60,14 +69,66 @@ const saveTestFile = async (testContent) => {
 
         // Format with Prettier
         let formattedContent = contentStr;
-        try {
+        const tryFormat = async (input) => {
             const prettierOptions = (await prettier.resolveConfig(absolutePath)) || { semi: true, singleQuote: true, parser: 'babel' };
-            // Fallback parser if filepath doesn't help
             if (!prettierOptions.parser) prettierOptions.parser = 'babel';
-            formattedContent = prettier.format(contentStr, { ...prettierOptions, filepath: absolutePath });
+            return prettier.format(input, { ...prettierOptions, filepath: absolutePath });
+        };
+
+        const sanitizeExpectStringHelpers = (input) => {
+            const targets = ['expect.stringContaining("', 'expect.stringMatching("'];
+            let output = '';
+            let idx = 0;
+
+            while (idx < input.length) {
+                let nextIndex = -1;
+                let matched = '';
+                for (const t of targets) {
+                    const i = input.indexOf(t, idx);
+                    if (i !== -1 && (nextIndex === -1 || i < nextIndex)) {
+                        nextIndex = i;
+                        matched = t;
+                    }
+                }
+                if (nextIndex === -1) {
+                    output += input.slice(idx);
+                    break;
+                }
+
+                output += input.slice(idx, nextIndex);
+                const start = nextIndex + matched.length;
+                const end = input.indexOf('")', start);
+                if (end === -1) {
+                    output += input.slice(nextIndex);
+                    break;
+                }
+
+                const inner = input.slice(start, end);
+                const escaped = inner.replace(/`/g, '\\`');
+                const helper = matched.startsWith('expect.stringMatching')
+                    ? 'expect.stringMatching'
+                    : 'expect.stringContaining';
+                output += `${helper}(String.raw\`${escaped}\`)`;
+                idx = end + 2;
+            }
+
+            return output;
+        };
+
+        try {
+            formattedContent = await tryFormat(contentStr);
         } catch (prettierError) {
-            // Best effort formatting
-            console.log(chalk.yellow(`⚠ Prettier formatting failed, saving raw: ${prettierError.message}`));
+            // Try a targeted sanitize pass for malformed string literals, then re-format
+            const sanitized = sanitizeExpectStringHelpers(contentStr);
+            if (sanitized !== contentStr) {
+                try {
+                    formattedContent = await tryFormat(sanitized);
+                } catch (secondError) {
+                    console.log(chalk.yellow(`⚠ Prettier formatting failed after sanitize, saving raw: ${secondError.message}`));
+                }
+            } else {
+                console.log(chalk.yellow(`⚠ Prettier formatting failed, saving raw: ${prettierError.message}`));
+            }
         }
 
         fs.writeFileSync(absolutePath, formattedContent);
@@ -78,9 +139,12 @@ const saveTestFile = async (testContent) => {
             framework: metaSource.framework || parsed.framework || 'jest'
         };
     } catch (error) {
-        console.log(chalk.red.bold(`❌ Failed to save test file: ${error.message}`));
+        saveTestFile.lastError = error?.message || 'Unknown error';
+        console.log(chalk.red.bold(`❌ Failed to save test file: ${saveTestFile.lastError}`));
         return null;
     }
 };
 
+saveTestFile.lastError = null;
+
 module.exports = { saveTestFile };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tng-sh/js",
-    "version": "0.1.9",
+    "version": "0.2.1",
     "description": "TNG JavaScript CLI",
     "repository": {
         "type": "git",
@@ -33,7 +33,8 @@
         "test": "node test.js"
     },
     "devDependencies": {
-        "@napi-rs/cli": "^2.18.0"
+        "@napi-rs/cli": "^2.18.0",
+        "@tng-sh/js": "^0.2.0"
     },
     "engines": {
         "node": ">= 10"
@@ -44,4 +45,4 @@
         "fast-glob": "^3.3.3",
         "prettier": "^2.8.8"
     }
-}
+}