@tng-sh/js 0.1.2 → 0.1.4

package/.tmp/tng-clone-data-1770062573900-923.json

@@ -0,0 +1 @@
+{"file_path":"/Users/claudiu/work/tng-inc/js-pie/test_duplicates.js","matches":[{"start1":1,"end1":13,"start2":16,"end2":28,"line_count":13,"node_count":12,"complexity_score":245,"algo":"structural"}]}

package/.tmp/tng-progress-control-1770062573779-154.json

@@ -0,0 +1 @@
+{"type":"step","step":1,"message":"Done!","percent":100}

package/.tmp/tng_sh_js-49dc3b9a.napi_type_def.tmp

@@ -0,0 +1,13 @@
+tng_sh_js:{"kind": "interface", "name": "CloneMatch", "js_doc": "", "def": "start1: number\nend1: number\nstart2: number\nend2: number\nlineCount: number\nnodeCount: number\ncomplexityScore: number\nalgo: string", "original_name": "CloneMatch"}
+tng_sh_js:{"kind": "fn", "name": "getFileOutline", "js_doc": "/**\n * Analyzes a JavaScript/TypeScript file and returns its structural outline as a JSON string.\n * Contains information about classes and methods found in the file.\n */\n", "def": "export declare function getFileOutline(filePath: string): string"}
+tng_sh_js:{"kind": "fn", "name": "getProjectMetadata", "js_doc": "/**\n * Gathers project-wide metadata from package.json and related files.\n * Returns a JSON string containing dependencies, frameworks, and project type.\n */\n", "def": "export declare function getProjectMetadata(projectRoot: string): string"}
+tng_sh_js:{"kind": "fn", "name": "findCallSites", "js_doc": "/**\n * Searches the project for all locations where a specific method is called.\n * Uses ripgrep under the hood for high performance.\n */\n", "def": "export declare function findCallSites(projectRoot: string, methodName: string): string"}
+tng_sh_js:{"kind": "fn", "name": "ping", "js_doc": "/** Pings the TNG API to verify connectivity and API key validity. */\n", "def": "export declare function ping(baseUrl: string, apiKey?: string | undefined | null): string"}
+tng_sh_js:{"kind": "fn", "name": "submitJob", "js_doc": "/** Submits a test generation job to the API and returns the numeric job ID. */\n", "def": "export declare function submitJob(baseUrl: string, apiKey: string, payloadJson: string): number"}
+tng_sh_js:{"kind": "fn", "name": "getUserStats", "js_doc": "/** Fetches usage statistics for the authenticated user from the API. */\n", "def": "export declare function getUserStats(baseUrl: string, apiKey: string): string"}
+tng_sh_js:{"kind": "fn", "name": "runAudit", "js_doc": "/**\n * Orchestrates the code audit process.\n * Analyzes the source, builds context, and streams results via the provided callback.\n */\n", "def": "export declare function runAudit(filePath: string, methodName: string, className: string | undefined | null, testType: string | undefined | null, configJson: string, callback: (...args: any[]) => any): string"}
+tng_sh_js:{"kind": "fn", "name": "applyEdit", "js_doc": "/**\n * Applies a single edit operation to a file.\n * Uses backup and atomic write for safety.\n */\n", "def": "export declare function applyEdit(filePath: string, search: string, replace: string, lineHint?: number | undefined | null): string"}
+tng_sh_js:{"kind": "fn", "name": "applyEditsAtomic", "js_doc": "/**\n * Applies multiple edit operations atomically.\n * All succeed or all fail (with rollback).\n */\n", "def": "export declare function applyEditsAtomic(operationsJson: string): string"}
+tng_sh_js:{"kind": "fn", "name": "generateTest", "js_doc": "/**\n * Orchestrates the test generation process.\n * Analyzes code, submits a job, and polls for the final generated test.\n */\n", "def": "export declare function generateTest(filePath: string, methodName: string, className: string | undefined | null, testType: string | undefined | null, configJson: string, callback: (...args: any[]) => any): string"}
+tng_sh_js:{"kind": "fn", "name": "getSymbolicTrace", "js_doc": "/** Analyzes a method and generates a symbolic execution trace. */\n", "def": "export declare function getSymbolicTrace(filePath: string, methodName: string, className?: string | undefined | null): string"}
+tng_sh_js:{"kind": "fn", "name": "analyzeClones", "js_doc": "/**\n * Analyzes a file for code clones (duplicates).\n * Returns a JSON string containing the matches found.\n */\n", "def": "export declare function analyzeClones(projectRoot: string, filePath: string, level: string): string"}

package/.tmp/tng_sh_js-49dc3b9a.napi_wasi_register.tmp

@@ -0,0 +1,13 @@
+tng_sh_js: __napi_register__CloneMatch_struct_0
+tng_sh_js: __napi_register__get_file_outline_1
+tng_sh_js: __napi_register__get_project_metadata_2
+tng_sh_js: __napi_register__find_call_sites_3
+tng_sh_js: __napi_register__ping_4
+tng_sh_js: __napi_register__submit_job_5
+tng_sh_js: __napi_register__get_user_stats_6
+tng_sh_js: __napi_register__run_audit_7
+tng_sh_js: __napi_register__apply_edit_8
+tng_sh_js: __napi_register__apply_edits_atomic_9
+tng_sh_js: __napi_register__generate_test_10
+tng_sh_js: __napi_register__get_symbolic_trace_11
+tng_sh_js: __napi_register__analyze_clones_12

package/bin/tng.js

@@ -28,7 +28,7 @@ process.on('uncaughtException', (err) => {
 program
     .name('tng')
     .description('TNG - Automated Test Generation, and audit generation for JavaScript')
-    .version('0.1.2');
+    .version('0.1.4');
 
 /**
  * @command init
@@ -210,22 +210,125 @@ program
     .option('-f, --file <path>', 'JavaScript file path')
     .option('-t, --type <type>', 'Component type (react_component, express_handler, etc) [required]')
     .option('-a, --audit', 'Run audit mode instead of test generation')
+    .option('--trace', 'Run symbolic trace visualization')
+    .option('-c, --clones', 'Run duplicate code detection')
+    .option('-l, --level <level>', 'Set clone detection level (1, 2, or all)', 'all')
     .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);
+
+                    // Launch Go UI
+                    const session = new GoUISession();
+                    const binaryPath = session._binaryPath;
+
+                    const { spawnSync } = require('child_process');
+                    spawnSync(binaryPath, ['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;
+            }
+
             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.file && !options.method) {
-            console.log(chalk.yellow('Specify a method with -m, use --outline to see methods, or run "tng i" for full selection.'));
+            if (options.clones) {
+                runClones(options.file, options.level || 'all', 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) {
             launchInteractive();
         }
     });
 
+/**
+ * Logic to run clone detection
+ */
+async function runClones(filePath, level, jsonMode = false) {
+    const { analyzeClones } = 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);
+    }
+
+    const GoUISession = require('../lib/goUiSession');
+    const session = new GoUISession();
+
+    if (jsonMode) {
+        const { JsonSession } = require('../lib/jsonSession');
+        const jsonSession = new JsonSession();
+        jsonSession.start();
+        try {
+            const matchesJson = analyzeClones(projectRoot, absolutePath, level);
+            const matches = JSON.parse(matchesJson);
+            jsonSession.showClones(absolutePath, matches);
+            jsonSession.stop();
+        } catch (e) {
+            jsonSession.displayError(e.message);
+            jsonSession.stop();
+            process.exit(1);
+        }
+        return;
+    }
+
+    console.log(chalk.blue(`🔍 Analyzing clones in ${filePath}...`));
+
+    try {
+        const matches = await session.showProgress('Analyzing clones...', async (progress) => {
+            progress.update('Scanning structures...', { percent: 50 });
+            const matchesJson = analyzeClones(projectRoot, absolutePath, level);
+            const matches = JSON.parse(matchesJson);
+            progress.update('Done!', { percent: 100 });
+
+            // Short delay to let the user see 100%
+            await new Promise(r => setTimeout(r, 100));
+            return matches;
+        });
+
+        if (matches) {
+            session.showClones(absolutePath, matches);
+        }
+    } catch (e) {
+        console.log(chalk.red(`Error: ${e.message}`));
+        process.exit(1);
+    }
+}
+
 /**
  * @command fix
  * Apply a specific fix to a file

package/index.d.ts

@@ -3,6 +3,16 @@
 
 /* auto-generated by NAPI-RS */
 
+export interface CloneMatch {
+  start1: number
+  end1: number
+  start2: number
+  end2: number
+  lineCount: number
+  nodeCount: number
+  complexityScore: number
+  algo: string
+}
 /**
  * Analyzes a JavaScript/TypeScript file and returns its structural outline as a JSON string.
  * Contains information about classes and methods found in the file.
@@ -44,3 +54,10 @@ export declare function applyEditsAtomic(operationsJson: string): string
  * Analyzes code, submits a job, and polls for the final generated test.
  */
 export declare function generateTest(filePath: string, methodName: string, className: string | undefined | null, testType: string | undefined | null, configJson: string, callback: (...args: any[]) => any): string
+/** Analyzes a method and generates a symbolic execution trace. */
+export declare function getSymbolicTrace(filePath: string, methodName: string, className?: string | undefined | null): string
+/**
+ * Analyzes a file for code clones (duplicates).
+ * Returns a JSON string containing the matches found.
+ */
+export declare function analyzeClones(projectRoot: string, filePath: string, level: 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 } = nativeBinding
+const { getFileOutline, getProjectMetadata, findCallSites, ping, submitJob, getUserStats, runAudit, applyEdit, applyEditsAtomic, generateTest, getSymbolicTrace, analyzeClones } = nativeBinding
 
 module.exports.getFileOutline = getFileOutline
 module.exports.getProjectMetadata = getProjectMetadata
@@ -322,3 +322,5 @@ module.exports.runAudit = runAudit
 module.exports.applyEdit = applyEdit
 module.exports.applyEditsAtomic = applyEditsAtomic
 module.exports.generateTest = generateTest
+module.exports.getSymbolicTrace = getSymbolicTrace
+module.exports.analyzeClones = analyzeClones

package/lib/generateTestsUi.js

@@ -37,6 +37,12 @@ class GenerateTestsUI {
             } else if (choice === 'xray') {
                 const result = await this._showFileSelection(false, true);
                 if (result === 'exit') return 'exit';
+            } else if (choice === 'trace') {
+                const result = await this._showFileSelection(false, false, true);
+                if (result === 'exit') return 'exit';
+            } else if (choice === 'clones') {
+                const result = await this._showClonesSelection();
+                if (result === 'exit') return 'exit';
             } else if (choice === 'stats') {
                 await this._showStats();
             } else if (choice === 'about') {
@@ -98,7 +104,7 @@ class GenerateTestsUI {
         });
     }
 
-    async _showFileSelection(isAudit = false, isXray = false) {
+    async _showFileSelection(isAudit = false, isXray = false, isTrace = false) {
         const files = await this._getUserFiles();
 
         if (files.length === 0) {
@@ -112,19 +118,23 @@ class GenerateTestsUI {
             path: path.dirname(file)
         }));
 
-        const title = isXray ? 'Select File for X-Ray' : (isAudit ? 'Select JavaScript File to Audit' : 'Select JavaScript File');
+        let title = 'Select JavaScript File';
+        if (isAudit) title = 'Select JavaScript File to Audit';
+        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);
 
         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);
+        const result = await this._showMethodsForFile(selectedFile, isAudit, isXray, isTrace);
         if (result === 'main_menu') return 'main_menu';
         return result;
     }
 
-    async _showMethodsForFile(filePath, isAudit = false, isXray = false) {
+    async _showMethodsForFile(filePath, isAudit = false, isXray = false, isTrace = false) {
         let outline;
         try {
             const result = getFileOutline(filePath);
@@ -147,14 +157,23 @@ class GenerateTestsUI {
             methodData: m
         }));
 
-        const title = isXray ? `Select Method to X-Ray for ${fileName}` : (isAudit ? `Select Method to Audit for ${fileName}` : `Select Method for ${fileName}`);
+        let title = 'Select Method';
+        if (isAudit) title = `Select Method to 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);
+        if (selectedDisplay === 'back' || !selectedDisplay) return this._showFileSelection(isAudit, isXray, isTrace);
 
         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);
+            }
+
             if (isXray) {
                 const choice = await this._generateTestsForMethod(filePath, selectedMethod, 'visualize', false, true);
                 if (choice === 'main_menu') return 'main_menu';
@@ -657,6 +676,97 @@ class GenerateTestsUI {
             return [];
         }
     }
+
+    async _launchTrace(filePath, methodName) {
+        const { getSymbolicTrace } = require('../index');
+        const fs = require('fs');
+        const path = require('path');
+        const chalk = require('chalk');
+
+        try {
+            // 1. Generate Trace (with Spinner)
+            const result = this.goUiSession.showSpinner(`Tracing ${methodName}...`, () => {
+                try {
+                    const traceJson = getSymbolicTrace(filePath, methodName, null);
+                    const tmpDir = require('os').tmpdir();
+                    const f = path.join(tmpDir, `trace-${Date.now()}.json`);
+                    fs.writeFileSync(f, traceJson);
+                    return { success: true, file: f };
+                } catch (e) {
+                    return { success: false, message: e.message };
+                }
+            });
+
+            if (result && result.success && result.file) {
+                // 2. Show Trace UI
+                const { spawnSync } = require('child_process');
+                spawnSync(this.goUiSession._binaryPath, ['trace-results', '--file', result.file], {
+                    stdio: 'inherit'
+                });
+
+                try { fs.unlinkSync(result.file); } catch (e) { }
+            }
+
+        } catch (e) {
+            console.error(chalk.red(`Trace error: ${e.message}`));
+        }
+    }
+
+    async _showClonesSelection() {
+        const files = await this._getUserFiles();
+
+        if (files.length === 0) {
+            console.log(chalk.yellow('\nNo JavaScript or TypeScript files found in your project.\n'));
+            return 'back';
+        }
+
+        const cwd = process.cwd();
+        const items = files.map(file => ({
+            name: path.relative(cwd, file),
+            path: path.dirname(file)
+        }));
+
+        const selectedName = this.goUiSession.showListView('Select File for Duplicate Detection', items);
+
+        if (selectedName === 'back') return 'back';
+        if (!selectedName || selectedName === 'exit') return 'exit';
+
+        const selectedFile = path.resolve(cwd, selectedName);
+
+        // Show level selection
+        const level = this.goUiSession.showCloneMenu();
+        if (level === 'back') return this._showClonesSelection();
+
+        await this._runClones(selectedFile, level);
+        return 'main_menu';
+    }
+
+    async _runClones(filePath, level) {
+        const { analyzeClones } = require('../index');
+        const absolutePath = path.resolve(filePath);
+        const projectRoot = process.cwd();
+
+        console.log(chalk.blue(`🔍 Analyzing clones in ${path.relative(projectRoot, filePath)}...`));
+
+        try {
+            const matches = await this.goUiSession.showProgress('Analyzing clones...', async (progress) => {
+                progress.update('Scanning structures...', { percent: 50 });
+                const matchesJson = analyzeClones(projectRoot, absolutePath, level);
+                const matches = JSON.parse(matchesJson);
+                progress.update('Done!', { percent: 100 });
+
+                // Short delay to let the user see 100%
+                await new Promise(r => setTimeout(r, 100));
+                return matches;
+            });
+
+            if (matches) {
+                this.goUiSession.showClones(absolutePath, matches);
+            }
+        } catch (e) {
+            console.log(chalk.red(`Error: ${e.message}`));
+        }
+    }
 }
 
 module.exports = GenerateTestsUI;

package/lib/goUiSession.js

@@ -78,6 +78,30 @@ class GoUISession {
         }
     }
 
+    showCloneMenu() {
+        const outputFile = this._trackTempFile(this._createTempFile('clone-menu-output', '.txt'));
+
+        try {
+            const result = spawnSync(this._binaryPath, ['clone-menu', '--output', outputFile], {
+                stdio: 'inherit'
+            });
+
+            if (result.error) throw result.error;
+
+            if (!fs.existsSync(outputFile) || fs.statSync(outputFile).size === 0) {
+                return 'back';
+            }
+
+            const choice = fs.readFileSync(outputFile, 'utf8').trim();
+            return choice || 'back';
+        } catch (error) {
+            console.error('Clone Menu error:', error.message);
+            return 'back';
+        } finally {
+            this._cleanupTempFile(outputFile);
+        }
+    }
+
     showListView(title, items) {
         const dataJson = JSON.stringify({ title, items });
         const outputFile = this._trackTempFile(this._createTempFile('list-view-output', '.txt'));
@@ -148,6 +172,22 @@ class GoUISession {
         }
     }
 
+    showSystemStatus(statusData) {
+        const dataJson = JSON.stringify(statusData);
+        const inputFile = this._trackTempFile(this._createTempFile('system-status', '.json'));
+
+        try {
+            fs.writeFileSync(inputFile, dataJson);
+            spawnSync(this._binaryPath, ['system-status', '--file', inputFile], {
+                stdio: 'inherit'
+            });
+        } catch (error) {
+            console.error('System status error:', error.message);
+        } finally {
+            this._cleanupTempFile(inputFile);
+        }
+    }
+
     showAbout() {
         try {
             spawnSync(this._binaryPath, ['about'], {
@@ -311,6 +351,24 @@ class GoUISession {
         }
     }
 
+    async showClones(filePath, results) {
+        const dataJson = JSON.stringify({ file_path: filePath, matches: results });
+        const inputFile = this._trackTempFile(this._createTempFile('clone-data', '.json'));
+
+        try {
+            fs.writeFileSync(inputFile, dataJson);
+
+            spawnSync(this._binaryPath, ['clones', '--file', inputFile], {
+                stdio: 'inherit',
+                env: process.env
+            });
+        } catch (error) {
+            console.error('Clone results display error:', error.message);
+        } finally {
+            this._cleanupTempFile(inputFile);
+        }
+    }
+
     async showStreamingAuditResults(methodName, className, sourceCode) {
         const outputFile = this._trackTempFile(this._createTempFile('audit-choice', '.txt'));
 
@@ -374,6 +432,27 @@ class GoUISession {
         }
     }
 
+    showAuthError(message = 'Authentication failed') {
+        try {
+            spawnSync(this._binaryPath, ['auth-error', '--message', message], {
+                stdio: 'inherit'
+            });
+        } catch (error) {
+            console.error('Auth error:', error.message);
+        }
+    }
+
+    showConfigError(missing = []) {
+        try {
+            const dataJson = JSON.stringify({ missing });
+            spawnSync(this._binaryPath, ['config-error', '--data', dataJson], {
+                stdio: 'inherit'
+            });
+        } catch (error) {
+            console.error('Config error:', error.message);
+        }
+    }
+
     _findGoUiBinary() {
         const platform = process.platform;
         const arch = process.arch;
@@ -397,8 +476,20 @@ class GoUISession {
 
     _createTempFile(prefix, suffix) {
         const tmpDir = os.tmpdir();
-        const filePath = path.join(tmpDir, `tng-${prefix}-${Date.now()}-${Math.floor(Math.random() * 1000)}${suffix}`);
-        fs.writeFileSync(filePath, '');
+        const fileName = `tng-${prefix}-${Date.now()}-${Math.floor(Math.random() * 1000)}${suffix}`;
+        let filePath = path.join(tmpDir, fileName);
+
+        try {
+            fs.writeFileSync(filePath, '');
+        } catch (e) {
+            // Fallback to local directory if system tmp is not writable
+            const localTmp = path.join(process.cwd(), '.tng-tmp');
+            if (!fs.existsSync(localTmp)) {
+                fs.mkdirSync(localTmp, { recursive: true });
+            }
+            filePath = path.join(localTmp, fileName);
+            fs.writeFileSync(filePath, '');
+        }
         return filePath;
     }
 

package/lib/jsonSession.js

@@ -66,6 +66,10 @@ class JsonSession {
         this.emitEvent('result', auditResult || {});
     }
 
+    showClones(filePath, results) {
+        this.emitEvent('clones', { file_path: filePath, matches: results });
+    }
+
     showTestResults(title, passed, failed, errors, total, results = []) {
         this.emitEvent('test_results', {
             title: title || 'Test Results',
@@ -105,7 +109,7 @@ class JsonSession {
 
     emitEvent(type, data = {}) {
         try {
-            const event = { type, ...data, timestamp: Date.now() };
+            const event = { type, ...data };
             console.log(JSON.stringify(event));
         } catch (e) {
             // If serialization fails (e.g. circular ref), emit minimal error

package/package.json

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