@tng-sh/js 0.2.0 → 0.2.4

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.4');
 
 /**
  * Copy text to system clipboard
@@ -253,113 +253,175 @@ 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('--callsites', 'Find in-repo call sites for a method')
+    .option('--class <name>', 'Class/module name to disambiguate methods when multiple classes define the same method in a file')
     .option('--json', 'Output results as JSON events (machine-readable)')
 
     .action(async (options) => {
-        if (options.method && options.file) {
-            if (options.trace) {
-                const { getSymbolicTrace } = require('../index');
-                const GoUISession = require('../lib/goUiSession');
-
-                try {
-                    const traceJson = getSymbolicTrace(
-                        path.resolve(options.file),
-                        options.method,
-                        null
-                    );
-
-                    if (options.json) {
-                        console.log(traceJson);
-                        return;
-                    }
-
-                    // Create temp file for the trace
-                    const tmpDir = require('os').tmpdir();
-                    const tmpFile = path.join(tmpDir, `trace-${Date.now()}.json`);
-                    fs.writeFileSync(tmpFile, traceJson);
+        if (options.callsites) {
+            if (!options.method) {
+                console.log(chalk.red('Error: --method is required for call site analysis.'));
+                process.exit(1);
+            }
 
-                    // Launch Go UI
-                    const session = new GoUISession();
-                    const binaryPath = session._binaryPath;
+            try {
+                const { findCallSites } = require('../index');
+                const projectRoot = process.cwd();
+                const resultJson = findCallSites(projectRoot, options.method);
 
-                    const { spawnSync } = require('child_process');
-                    spawnSync(binaryPath, ['js-trace-results', '--file', tmpFile], {
-                        stdio: 'inherit'
-                    });
+                if (options.json) {
+                    console.log(resultJson);
+                    return;
+                }
 
-                    // Cleanup
-                    try { fs.unlinkSync(tmpFile); } catch (e) { }
+                const parsed = JSON.parse(resultJson);
+                const sites = Array.isArray(parsed) ? parsed : (parsed.call_sites || parsed.sites || parsed);
+                if (!sites || sites.length === 0) {
+                    console.log(chalk.green('\nNo call sites found in this project. You might be safe!'));
+                    return;
+                }
 
-                } catch (e) {
-                    console.log(chalk.red(`Trace failed: ${e.message}`));
-                    process.exit(1);
+                console.log(chalk.blue(`\nFound ${sites.length} call sites:\n`));
+                sites.slice(0, 200).forEach((site) => {
+                    const file = site.file || 'unknown';
+                    const line = site.line || 0;
+                    const content = site.content || '';
+                    console.log(`${chalk.yellow(file)}:${chalk.cyan(line)} ${content}`);
+                });
+                if (sites.length > 200) {
+                    console.log(chalk.dim(`\n... ${sites.length - 200} more`));
                 }
                 return;
+            } catch (e) {
+                console.log(chalk.red(`Error: ${e.message}`));
+                process.exit(1);
             }
+        }
+        // 1. Symbolic Trace
+        if (options.method && options.file && options.trace) {
+            const { getSymbolicTrace } = require('../index');
+            const GoUISession = require('../lib/goUiSession');
 
-            if (options.xray) {
-                const config = loadConfig();
-                const { generateTest: nativeGenerateTest } = require('../index');
+            try {
+            const traceJson = getSymbolicTrace(
+                path.resolve(options.file),
+                options.method,
+                options.class || null
+            );
 
-                try {
-                    const resultJson = nativeGenerateTest(
-                        path.resolve(options.file),
-                        options.method,
-                        null,
-                        'visualize',
-                        JSON.stringify(config),
-                        (msg, percent) => {
-                            if (options.json) return;
-                            if (percent % 20 === 0) console.log(chalk.dim(`[${percent}%] ${msg}`));
-                        }
-                    );
-
-                    if (options.json) {
-                        console.log(resultJson);
-                        return;
-                    }
+                if (options.json) {
+                    console.log(traceJson);
+                    return;
+                }
+
+                // Create temp file for the trace
+                const tmpDir = require('os').tmpdir();
+                const tmpFile = path.join(tmpDir, `trace-${Date.now()}.json`);
+                fs.writeFileSync(tmpFile, traceJson);
+
+                // Launch Go UI
+                const session = new GoUISession();
+                const binaryPath = session._binaryPath;
+
+                const { spawnSync } = require('child_process');
+                spawnSync(binaryPath, ['js-trace-results', '--file', tmpFile], {
+                    stdio: 'inherit'
+                });
+
+                // Cleanup
+                try { fs.unlinkSync(tmpFile); } catch (e) { }
+
+            } catch (e) {
+                console.log(chalk.red(`Trace failed: ${e.message}`));
+                process.exit(1);
+            }
+            return;
+        }
+
+        // 2. X-Ray
+        if (options.method && options.file && options.xray) {
+            const config = loadConfig();
+            const { generateTest: nativeGenerateTest } = require('../index');
 
-                    // For global --xray, we just launch the Premium UI directly if not JSON
-                    const GoUISession = require('../lib/goUiSession');
-                    const session = new GoUISession();
-                    let mermaidCode = "";
-                    let explanation = "";
-                    try {
-                        const parsed = JSON.parse(resultJson);
-                        mermaidCode = parsed.mermaid_code || resultJson;
-                        explanation = parsed.explanation || "";
-                    } catch (e) {
-                        mermaidCode = resultJson;
+            try {
+                const resultJson = nativeGenerateTest(
+                    path.resolve(options.file),
+                    options.method,
+                    options.class || null,
+                    'visualize',
+                    JSON.stringify(config),
+                    (msg, percent) => {
+                        if (options.json) return;
+                        if (percent % 20 === 0) console.log(chalk.dim(`[${percent}%] ${msg}`));
                     }
+                );
 
-                    // Copy to clipboard
-                    copyToClipboard(mermaidCode);
+                if (options.json) {
+                    console.log(resultJson);
+                    return;
+                }
 
-                    await session.showXrayResults(options.method, '', mermaidCode, explanation);
+                const GoUISession = require('../lib/goUiSession');
+                const session = new GoUISession();
+                let mermaidCode = "";
+                let explanation = "";
+                try {
+                    const parsed = JSON.parse(resultJson);
+                    mermaidCode = parsed.mermaid_code || resultJson;
+                    explanation = parsed.explanation || "";
                 } catch (e) {
-                    console.log(chalk.red(`X-Ray failed: ${e.message}`));
-                    process.exit(1);
+                    mermaidCode = resultJson;
                 }
-                return;
-            }
 
-            if (!options.type && !options.audit) {
-                console.log(chalk.red('Error: --type <type> is required.'));
+                copyToClipboard(mermaidCode);
+                await session.showXrayResults(options.method, '', mermaidCode, explanation);
+            } catch (e) {
+                console.log(chalk.red(`X-Ray failed: ${e.message}`));
                 process.exit(1);
             }
-            generateTest(options.file, options.method, options.type, options.audit, options.json);
-        } else if (options.file && !options.method) {
-            if (options.clones) {
-                await runClones(options.file, options.level || 'all', options.json);
-            } else if (options.deadcode) {
+            return;
+        }
+
+        // 3. Impact Analysis
+        if (options.method && options.file && options.impact) {
+            await runImpact(options.file, options.method, options.json, options.class || null);
+            return;
+        }
+
+        // 4. Clone Detection
+        if (options.file && options.clones) {
+            await runClones(options.file, options.level || 'all', options.json);
+            return;
+        }
+
+        // 5. Dead Code Analysis
+        if (options.deadcode) {
+            if (options.all) {
+                await runDeadCodeRepo(options.json);
+            } else if (options.file) {
                 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.'));
+                console.log(chalk.red('Error: --file <path> or --all is required for deadcode analysis.'));
+                process.exit(1);
+            }
+            return;
+        }
+
+        // 6. Test Generation / Audit (Method + File required)
+        if (options.method && options.file) {
+            if (!options.type && !options.audit) {
+                console.log(chalk.red('Error: --type <type> is required.'));
+                process.exit(1);
             }
-        } else if (!options.file && !options.method && process.argv.length <= 2) {
-            launchInteractive();
+            generateTest(options.file, options.method, options.type, options.audit, options.json, options.class || null);
+            return;
         }
+
+        // 7. Interactive Fallback
+        launchInteractive();
     });
 
 /**
@@ -439,7 +501,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 +531,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
@@ -507,7 +707,7 @@ program
 /**
  * Logic to generate test or run audit (delegates to native binary)
  */
-async function generateTest(filePath, methodName, testType, auditMode = false, jsonMode = false) {
+async function generateTest(filePath, methodName, testType, auditMode = false, jsonMode = false, className = null) {
     const config = loadConfig();
 
     // Initialize JSON session if requested
@@ -577,7 +777,7 @@ async function generateTest(filePath, methodName, testType, auditMode = false, j
             resultJson = runAudit(
                 absolutePath,
                 methodName,
-                null, // class_name
+                className,
                 testType || null,
                 JSON.stringify(config),
                 callback
@@ -586,7 +786,7 @@ async function generateTest(filePath, methodName, testType, auditMode = false, j
             resultJson = nativeGenerateTest(
                 absolutePath,
                 methodName,
-                null, // class_name
+                className,
                 testType || null,
                 JSON.stringify(config),
                 callback
@@ -654,4 +854,76 @@ program.on('--help', () => {
     console.log('');
 });
 
+/**
+ * Logic to run impact analysis
+ */
+async function runImpact(filePath, methodName, jsonMode = false, className = null) {
+    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, className);
+            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, className);
+        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, className?: string | undefined | null): 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

@@ -6,7 +6,6 @@ const GoUISession = require('./goUiSession');
 const { getFileOutline, generateTest, ping, getUserStats } = require('../index');
 const { loadConfig } = require('./config');
 const { saveTestFile } = require('./saveFile');
-const { applyFix } = require('./fixApplier');
 
 class GenerateTestsUI {
     constructor(cliMode = false) {
@@ -34,6 +33,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 +107,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 +126,7 @@ class GenerateTestsUI {
 
         let title = 'Select JavaScript File';
         if (isAudit) title = 'Select JavaScript File to Audit';
+        else if (isImpact) title = 'Select JavaScript File for Regression Check';
         else if (isXray) title = 'Select File for X-Ray';
         else if (isTrace) title = 'Select File for Symbolic Trace';
 
@@ -132,76 +136,88 @@ 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);
         const items = methods.map(m => ({
-            name: m.class_name ? `${m.class_name}.${m.name}` : m.name,
+            name: m.class_name ? `${m.class_name}#${m.name}` : m.name,
             path: `Function in ${fileName}`,
             methodData: m
         }));
 
         let title = 'Select Method';
         if (isAudit) title = `Select Method to Audit for ${fileName}`;
+        else if (isImpact) title = `Select Method for Regression Check 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);
+                await this._launchTrace(filePath, selectedMethod.name, selectedMethod.class_name || null);
+                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 +245,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, method.class_name || null);
+                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: 'Regression check 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) {
@@ -677,7 +599,7 @@ class GenerateTestsUI {
         }
     }
 
-    async _launchTrace(filePath, methodName) {
+    async _launchTrace(filePath, methodName, className) {
         const { getSymbolicTrace } = require('../index');
         const fs = require('fs');
         const path = require('path');
@@ -687,7 +609,7 @@ class GenerateTestsUI {
             // 1. Generate Trace (with Spinner)
             const result = this.goUiSession.showSpinner(`Tracing ${methodName}...`, () => {
                 try {
-                    const traceJson = getSymbolicTrace(filePath, methodName, null);
+                    const traceJson = getSymbolicTrace(filePath, methodName, className || null);
                     const tmpDir = require('os').tmpdir();
                     const f = path.join(tmpDir, `trace-${Date.now()}.json`);
                     fs.writeFileSync(f, traceJson);

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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@tng-sh/js",
-    "version": "0.2.0",
+    "version": "0.2.4",
     "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"
     }
-}
+}