@tng-sh/js 0.2.1 → 0.2.5

package/bin/tng.js

@@ -5,6 +5,7 @@ const chalk = require('chalk');
 const fs = require('fs');
 const path = require('path');
 const { loadConfig } = require('../lib/config');
+const { isIgnoredPath, filterIgnoredPaths, ignoredMessage } = require('../lib/ignore');
 const { saveTestFile } = require('../lib/saveFile');
 const { ping, getUserStats } = require('../index');
 const { applyFix } = require('../lib/fixApplier');
@@ -28,7 +29,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.2.1');
+    .version('0.2.5');
 
 /**
  * Copy text to system clipboard
@@ -92,7 +93,11 @@ module.exports = {
   TEST_FRAMEWORK: "jest",
 
   // Test Directory
-  TEST_DIRECTORY: "tests"
+  TEST_DIRECTORY: "tests",
+
+  // Ignore paths (relative to project root)
+  IGNORE_FILES: [],
+  IGNORE_FOLDERS: []
 };
 `;
         fs.writeFileSync(configPath, content);
@@ -189,11 +194,16 @@ program
             process.exit(1);
         }
 
+        const config = loadConfig();
+        const resolvedPath = path.resolve(options.file);
+        if (isIgnoredPath(resolvedPath, config)) {
+            console.log(chalk.red(ignoredMessage()));
+            process.exit(1);
+        }
+
         console.log(chalk.blue(`🔍 Generating X-Ray for ${options.method} in ${options.file}...`));
 
         try {
-            const config = loadConfig();
-
             // Re-use logic similar to _handleXrayFlow but tailored for CLI non-interactive output
             const { generateTest } = require('../index');
 
@@ -256,139 +266,183 @@ program
     .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');
+            const config = loadConfig();
+            const resolvedPath = path.resolve(options.file);
+            if (isIgnoredPath(resolvedPath, config)) {
+                console.log(chalk.red(ignoredMessage()));
+                process.exit(1);
             }
 
-            if (options.xray) {
-                const config = loadConfig();
-                const { generateTest: nativeGenerateTest } = require('../index');
+            try {
+            const traceJson = getSymbolicTrace(
+                resolvedPath,
+                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;
+                }
 
-                    // 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;
-                    }
+                // Create temp file for the trace
+                const tmpDir = require('os').tmpdir();
+                const tmpFile = path.join(tmpDir, `trace-${Date.now()}.json`);
+                fs.writeFileSync(tmpFile, traceJson);
 
-                    // Copy to clipboard
-                    copyToClipboard(mermaidCode);
+                // Launch Go UI
+                const session = new GoUISession();
+                const binaryPath = session._binaryPath;
 
-                    await session.showXrayResults(options.method, '', mermaidCode, explanation);
-                } catch (e) {
-                    console.log(chalk.red(`X-Ray failed: ${e.message}`));
-                    process.exit(1);
-                }
-                return;
-            }
+                const { spawnSync } = require('child_process');
+                spawnSync(binaryPath, ['js-trace-results', '--file', tmpFile], {
+                    stdio: 'inherit'
+                });
 
+                // Cleanup
+                try { fs.unlinkSync(tmpFile); } catch (e) { }
 
-            if (options.impact) {
-                await runImpact(options.file, options.method, options.json);
-                return;
+            } catch (e) {
+                console.log(chalk.red(`Trace failed: ${e.message}`));
+                process.exit(1);
             }
+            return;
+        }
 
-            if (!options.type && !options.audit) {
-                console.log(chalk.red('Error: --type <type> is required.'));
+        // 2. X-Ray
+        if (options.method && options.file && options.xray) {
+            const config = loadConfig();
+            const resolvedPath = path.resolve(options.file);
+            if (isIgnoredPath(resolvedPath, config)) {
+                console.log(chalk.red(ignoredMessage()));
                 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) {
-                if (options.all) {
-                    await runDeadCodeRepo(options.json);
-                } else {
-                    await runDeadCode(options.file, options.json);
+            const { generateTest: nativeGenerateTest } = require('../index');
+
+            try {
+                const resultJson = nativeGenerateTest(
+                    resolvedPath,
+                    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}`));
+                    }
+                );
+
+                if (options.json) {
+                    console.log(resultJson);
+                    return;
                 }
-            } else {
-                console.log(chalk.yellow('Specify a method with -m, use --outline to see methods, or run "tng i" for full selection.'));
-            }
-            if (options.xray) {
-                // ... (existing xray logic) ...
-                return;
+
+                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;
+                }
+
+                copyToClipboard(mermaidCode);
+                await session.showXrayResults(options.method, '', mermaidCode, explanation);
+            } catch (e) {
+                console.log(chalk.red(`X-Ray failed: ${e.message}`));
+                process.exit(1);
             }
+            return;
+        }
 
-            if (options.impact) {
-                await runImpact(options.file, options.method, options.json);
-                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.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);
             }
-            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();
+            generateTest(options.file, options.method, options.type, options.audit, options.json, options.class || null);
+            return;
         }
+
+        // 7. Interactive Fallback
+        launchInteractive();
     });
 
 /**
@@ -396,6 +450,7 @@ program
  */
 async function runClones(filePath, level, jsonMode = false) {
     const { analyzeClones } = require('../index');
+    const config = loadConfig();
     const absolutePath = path.resolve(filePath);
     const projectRoot = process.cwd();
 
@@ -403,6 +458,10 @@ async function runClones(filePath, level, jsonMode = false) {
         console.log(chalk.red(`File not found: ${filePath}`));
         process.exit(1);
     }
+    if (isIgnoredPath(absolutePath, config)) {
+        console.log(chalk.red(ignoredMessage()));
+        process.exit(1);
+    }
 
     const GoUISession = require('../lib/goUiSession');
     const session = new GoUISession();
@@ -452,12 +511,17 @@ async function runClones(filePath, level, jsonMode = false) {
  */
 async function runDeadCode(filePath, jsonMode = false) {
     const { detectDeadCode } = require('../index');
+    const config = loadConfig();
     const absolutePath = path.resolve(filePath);
 
     if (!fs.existsSync(absolutePath)) {
         console.log(chalk.red(`File not found: ${filePath}`));
         process.exit(1);
     }
+    if (isIgnoredPath(absolutePath, config)) {
+        console.log(chalk.red(ignoredMessage()));
+        process.exit(1);
+    }
 
     const GoUISession = require('../lib/goUiSession');
     const session = new GoUISession();
@@ -498,13 +562,14 @@ async function runDeadCode(filePath, jsonMode = false) {
     }
 }
 
-function listDeadCodeFiles(projectRoot) {
+function listDeadCodeFiles(projectRoot, config) {
     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'));
+        const withoutTypes = files.filter((f) => !f.endsWith('.d.ts'));
+        return filterIgnoredPaths(withoutTypes, config, projectRoot);
     } catch (e) {
         return [];
     }
@@ -513,7 +578,8 @@ function listDeadCodeFiles(projectRoot) {
 async function runDeadCodeRepo(jsonMode = false) {
     const { detectDeadCode } = require('../index');
     const projectRoot = process.cwd();
-    const files = listDeadCodeFiles(projectRoot);
+    const config = loadConfig();
+    const files = listDeadCodeFiles(projectRoot, config);
 
     if (files.length === 0) {
         console.log(chalk.yellow('No files found for dead code analysis.'));
@@ -674,7 +740,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
@@ -706,6 +772,16 @@ async function generateTest(filePath, methodName, testType, auditMode = false, j
         }
         process.exit(1);
     }
+    if (isIgnoredPath(absolutePath, config)) {
+        const message = ignoredMessage();
+        if (jsonSession) {
+            jsonSession.displayError(message);
+            jsonSession.stop();
+        } else {
+            console.log(chalk.red(message));
+        }
+        process.exit(1);
+    }
 
     const { runAudit, generateTest: nativeGenerateTest } = require('../index');
 
@@ -744,7 +820,7 @@ async function generateTest(filePath, methodName, testType, auditMode = false, j
             resultJson = runAudit(
                 absolutePath,
                 methodName,
-                null, // class_name
+                className,
                 testType || null,
                 JSON.stringify(config),
                 callback
@@ -753,7 +829,7 @@ async function generateTest(filePath, methodName, testType, auditMode = false, j
             resultJson = nativeGenerateTest(
                 absolutePath,
                 methodName,
-                null, // class_name
+                className,
                 testType || null,
                 JSON.stringify(config),
                 callback
@@ -814,6 +890,10 @@ program.on('--help', () => {
     console.log('  3: Fuzzy (Fuzzy structural, catches patterns with small variations)');
     console.log('  all: Runs all detection levels (default)');
     console.log('');
+    console.log('Ignore Paths (from tng.config.js):');
+    console.log('  IGNORE_FILES:   [ "relative/path/file.js", ... ]');
+    console.log('  IGNORE_FOLDERS: [ "relative/path/folder", ... ]');
+    console.log('');
     console.log('X-Ray Visualization:');
     console.log('  tng src/components/MyComponent.js render --xray');
     console.log('  tng --file=api/handler.js --method=post --xray --json');
@@ -824,8 +904,9 @@ program.on('--help', () => {
 /**
  * Logic to run impact analysis
  */
-async function runImpact(filePath, methodName, jsonMode = false) {
+async function runImpact(filePath, methodName, jsonMode = false, className = null) {
     const { analyzeImpact } = require('../index');
+    const config = loadConfig();
     const absolutePath = path.resolve(filePath);
     const projectRoot = process.cwd();
 
@@ -833,10 +914,14 @@ async function runImpact(filePath, methodName, jsonMode = false) {
         console.log(chalk.red(`File not found: ${filePath}`));
         process.exit(1);
     }
+    if (isIgnoredPath(absolutePath, config)) {
+        console.log(chalk.red(ignoredMessage()));
+        process.exit(1);
+    }
 
     if (jsonMode) {
         try {
-            const resultJson = analyzeImpact(projectRoot, absolutePath, methodName);
+            const resultJson = analyzeImpact(projectRoot, absolutePath, methodName, className);
             console.log(resultJson);
         } catch (e) {
             console.error(JSON.stringify({ error: e.message }));
@@ -848,7 +933,7 @@ async function runImpact(filePath, methodName, jsonMode = false) {
     console.log(chalk.blue(`💥 Analyzing impact for ${methodName} in ${filePath}...`));
 
     try {
-        const resultJson = analyzeImpact(projectRoot, absolutePath, methodName);
+        const resultJson = analyzeImpact(projectRoot, absolutePath, methodName, className);
         const result = JSON.parse(resultJson);
 
         if (result.status === 'error') {

package/index.d.ts

@@ -69,4 +69,4 @@ 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
+export declare function analyzeImpact(projectRoot: string, filePath: string, methodName: string, className?: string | undefined | null): string

package/lib/generateTestsUi.js

@@ -5,8 +5,8 @@ const chalk = require('chalk');
 const GoUISession = require('./goUiSession');
 const { getFileOutline, generateTest, ping, getUserStats } = require('../index');
 const { loadConfig } = require('./config');
+const { filterIgnoredPaths } = require('./ignore');
 const { saveTestFile } = require('./saveFile');
-const { applyFix } = require('./fixApplier');
 
 class GenerateTestsUI {
     constructor(cliMode = false) {
@@ -127,19 +127,23 @@ 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 (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';
 
-        const selectedName = this.goUiSession.showListView(title, items);
+        while (true) {
+            const selectedName = this.goUiSession.showListView(title, items);
 
-        if (selectedName === 'back') return 'back';
-        if (!selectedName || selectedName === 'exit') return 'exit';
+            if (selectedName === 'back') return 'back';
+            if (!selectedName || selectedName === 'exit') return 'exit';
 
-        const selectedFile = path.resolve(cwd, selectedName);
-        const result = await this._showMethodsForFile(selectedFile, isAudit, isXray, isTrace, isImpact);
-        if (result === 'main_menu') return 'main_menu';
-        return result;
+            const selectedFile = path.resolve(cwd, selectedName);
+            const result = await this._showMethodsForFile(selectedFile, isAudit, isXray, isTrace, isImpact);
+
+            if (result === 'main_menu') return 'main_menu';
+            if (result === 'exit') return 'exit';
+            // If result is 'back', we loop again
+        }
     }
 
     async _showMethodsForFile(filePath, isAudit = false, isXray = false, isTrace = false, isImpact = false) {
@@ -149,60 +153,60 @@ class GenerateTestsUI {
             outline = JSON.parse(result);
         } catch (e) {
             console.error(chalk.red(`\nError parsing file: ${e.message}\n`));
-            return this._showFileSelection(isAudit, isXray, isTrace, isImpact);
+            return 'back';
         }
 
         const methods = outline.methods || [];
         if (methods.length === 0) {
             this.goUiSession.showNoItems('methods');
-            return this._showFileSelection(isAudit, isXray, isTrace, isImpact);
+            return 'back';
         }
 
         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 to Impact 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, isImpact);
+        if (selectedDisplay === 'back' || !selectedDisplay) return 'back';
 
         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, isImpact);
+                await this._launchTrace(filePath, selectedMethod.name, selectedMethod.class_name || null);
+                return 'back';
             }
 
             if (isXray) {
                 const choice = await this._generateTestsForMethod(filePath, selectedMethod, 'visualize', false, true);
                 if (choice === 'main_menu') return 'main_menu';
-                return this._showFileSelection(isAudit, isXray, isTrace, isImpact);
+                return 'back';
             }
 
             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);
+                return 'back';
             }
 
             if (isAudit) {
                 const choice = await this._generateTestsForMethod(filePath, selectedMethod, null, true);
                 if (choice === 'main_menu') return 'main_menu';
-                return this._showFileSelection(isAudit, isXray, isTrace, isImpact);
+                return 'back';
             }
 
             const testType = this.goUiSession.showJsTestMenu();
-            if (testType === 'back') return this._showFileSelection(isAudit, isXray, isTrace, isImpact);
+            if (testType === 'back') return 'back';
 
             const finalType = testType === 'auto' ? null : testType;
             const choice = await this._generateTestsForMethod(filePath, selectedMethod, finalType, false);
@@ -211,7 +215,7 @@ class GenerateTestsUI {
                 this._showPostGenerationMenu(choice);
             }
         }
-        return this._showFileSelection(isAudit, isXray, isTrace, isImpact);
+        return 'back';
     }
 
     async _generateTestsForMethod(filePath, method, testType, isAudit = false, isXray = false, isImpact = false) {
@@ -250,7 +254,7 @@ class GenerateTestsUI {
         const { analyzeImpact } = require('../index');
         const projectRoot = process.cwd();
 
-        console.log(chalk.blue(`\n🔍 Analyzing impact for ${method.name}...`));
+        console.log(chalk.blue(`\nAnalyzing impact for ${method.name}...`));
 
         let impactResult;
         try {
@@ -259,7 +263,7 @@ class GenerateTestsUI {
                 // Artificial delay for UX
                 await new Promise(r => setTimeout(r, 300));
 
-                const json = analyzeImpact(projectRoot, filePath, method.name);
+                const json = analyzeImpact(projectRoot, filePath, method.name, method.class_name || null);
                 progress.update('Comparing logic...', { percent: 80 });
 
                 return json;
@@ -272,7 +276,7 @@ class GenerateTestsUI {
         }
 
         await this.goUiSession.showImpactResults(impactResult);
-        return { message: 'Impact audit complete' };
+        return { message: 'Regression check complete' };
     }
 
     async _handleAuditFlow(filePath, method, testType) {
@@ -281,7 +285,7 @@ class GenerateTestsUI {
         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}...`));
+        console.log(chalk.blue(`\nAuditing ${displayName}...`));
 
         let auditResult;
         try {
@@ -572,7 +576,7 @@ class GenerateTestsUI {
                 }
             }
         } catch (e) {
-            console.log(chalk.yellow(`\n⚠️ Failed to open editor: ${e.message}`));
+            console.log(chalk.yellow(`\n Failed to open editor: ${e.message}`));
         }
     }
 
@@ -589,18 +593,20 @@ class GenerateTestsUI {
         ];
 
         try {
-            return await glob(patterns, {
+            const files = await glob(patterns, {
                 ignore,
                 absolute: true,
                 onlyFiles: true
             });
+            const config = loadConfig();
+            return filterIgnoredPaths(files, config, process.cwd());
         } catch (e) {
             console.error(chalk.red(`\nError searching for files: ${e.message}\n`));
             return [];
         }
     }
 
-    async _launchTrace(filePath, methodName) {
+    async _launchTrace(filePath, methodName, className) {
         const { getSymbolicTrace } = require('../index');
         const fs = require('fs');
         const path = require('path');
@@ -610,7 +616,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);
@@ -649,19 +655,21 @@ class GenerateTestsUI {
             path: path.dirname(file)
         }));
 
-        const selectedName = this.goUiSession.showListView('Select File for Duplicate Detection', items);
+        while (true) {
+            const selectedName = this.goUiSession.showListView('Select File for Duplicate Detection', items);
 
-        if (selectedName === 'back') return 'back';
-        if (!selectedName || selectedName === 'exit') return 'exit';
+            if (selectedName === 'back') return 'back';
+            if (!selectedName || selectedName === 'exit') return 'exit';
 
-        const selectedFile = path.resolve(cwd, selectedName);
+            const selectedFile = path.resolve(cwd, selectedName);
 
-        // Show level selection
-        const level = this.goUiSession.showCloneMenu();
-        if (level === 'back') return this._showClonesSelection();
+            // Show level selection
+            const level = this.goUiSession.showCloneMenu();
+            if (level === 'back') continue;
 
-        await this._runClones(selectedFile, level);
-        return 'main_menu';
+            await this._runClones(selectedFile, level);
+            return 'main_menu';
+        }
     }
 
     async _runClones(filePath, level) {

package/lib/ignore.js

@@ -0,0 +1,56 @@
+const path = require('path');
+
+function normalizeEntry(entry) {
+    if (typeof entry !== 'string') return null;
+    const trimmed = entry.trim();
+    if (!trimmed) return null;
+    return trimmed.replace(/\\/g, '/');
+}
+
+function resolveConfigPath(entry, projectRoot) {
+    const normalized = normalizeEntry(entry);
+    if (!normalized) return null;
+    if (path.isAbsolute(normalized)) {
+        return path.resolve(normalized);
+    }
+    return path.resolve(projectRoot, normalized);
+}
+
+function isIgnoredPath(filePath, config = {}, projectRoot = process.cwd()) {
+    if (!filePath) return false;
+
+    const absolutePath = path.resolve(filePath);
+    const ignoreFiles = Array.isArray(config.IGNORE_FILES) ? config.IGNORE_FILES : [];
+    const ignoreFolders = Array.isArray(config.IGNORE_FOLDERS) ? config.IGNORE_FOLDERS : [];
+
+    for (const entry of ignoreFiles) {
+        const resolved = resolveConfigPath(entry, projectRoot);
+        if (resolved && resolved === absolutePath) {
+            return true;
+        }
+    }
+
+    for (const entry of ignoreFolders) {
+        const resolved = resolveConfigPath(entry, projectRoot);
+        if (!resolved) continue;
+        if (absolutePath === resolved) return true;
+        if (absolutePath.startsWith(resolved + path.sep)) return true;
+    }
+
+    return false;
+}
+
+function filterIgnoredPaths(paths, config = {}, projectRoot = process.cwd()) {
+    if (!Array.isArray(paths) || paths.length === 0) return [];
+    return paths.filter((p) => !isIgnoredPath(p, config, projectRoot));
+}
+
+function ignoredMessage() {
+    return 'Ignored by TNG config (ignore_files/ignore_folders). Remove it from config to proceed.';
+}
+
+module.exports = {
+    isIgnoredPath,
+    filterIgnoredPaths,
+    ignoredMessage
+};

package/package.json

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