tng 0.4.7 → 0.4.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7727b2d4c08387a0e8c876ec10b2a8f6eccd489012bd9f67a0a603edc3ac2355
-  data.tar.gz: 7bcd5620b9d3f655a535a340bcdeff03dc55732026f3778e99cea0dba1bfea82
+  metadata.gz: 1050b64ce05cdf8195c4bd1a5603161eea0f88c077ccd09e1ad2d3c17d78850f
+  data.tar.gz: 2c38ad45bd123379e2d24cfe4b20e538684c7969ece4dddc7b4d64e546b4c49d
 SHA512:
-  metadata.gz: 54e4257601da9e968ce490c289d5bc51988d24940cc8c4879a172622edbb789c0512f3aa3b787c2262fe4370869ed21c15f3e0c8a9816b81458eff491f0cc62f
-  data.tar.gz: da6a48c02b0a509c80fbee1192737176b193743e21e34320aa4a868224ae9de3cc9ef3dcce1ade936ece5297c89f5770759adc18f6e4e56979aee18fdc66dc0a
+  metadata.gz: 5f864c1e9dacc0c05d65304f1c640287c163e2f3d2882df4fa8220e4f656d70586894ddaf9c28fb14e920025802da5ceece8260a4bec42fd0fdfdff67354db90
+  data.tar.gz: e39fe64e2595c3a98fa96647eadc16bd178196fdbd5a831cf8edc20573a8095e687d317faf33daaf7090aeac8899548bf96a07cbb80a4d7ab38fbd2fc02b7707

data/README.md

@@ -1,12 +1,19 @@
-# TNG - AI-Powered Test Generation for Rails
+# TNG - AI-Powered Test Generation & Code Analysis for Rails
 
-TNG is an AI-powered test generation tool that automatically creates comprehensive tests for your Rails applications. It analyzes your code structure, authentication patterns, and configuration to generate high-quality, contextual tests that follow your project's conventions.
+TNG is a comprehensive AI-powered tool for Rails applications that combines intelligent test generation with advanced static analysis. Analyze your code structure, detect issues, find duplicates, and generate high-quality tests that follow your project's conventions.
 
 **Owner:** Binary Dreams LLC
 
-## Installation
+## Features
+
+- **🧪 AI Test Generation** - Generate comprehensive tests for controllers, models, services, and 20+ file types
+- **🔍 Code Audit** - Deep security, performance, and best-practice analysis
+- **🔬 Symbolic Trace** - Visualize execution paths and logic flow with Mermaid diagrams
+- **📊 Clone Detection** - Find duplicate code with 3 detection levels (Token, Structural, Fuzzy)
+- **💀 Dead Code Detection** - Identify unreachable code, unused variables, and unused private methods
+- **⚡ Blazing Fast** - Powered by Rust for near-instant analysis
 
-### Standard Installation
+## Installation
 
 Add this line to your application's Gemfile:
 
@@ -20,415 +27,378 @@ And then execute:
 bundle install
 ```
 
-## Configuration
+## Quick Start
+
+### 1. Initialize Configuration
 
-TNG requires proper configuration to generate high-quality tests. Generate the configuration file by running:
+Generate the configuration file:
 
 ```bash
 rails generate tng:install
 ```
 
-This creates `config/initializers/tng.rb` with a configuration template that you'll need to customize for your application. The generator will attempt to detect your existing setup and pre-configure common settings.
-
-### Configuration Options Explained
-
-#### API Configuration
-- **`api_key`**: Your TNG API key from https://app.tng.sh/
-- **`base_url`**: TNG service endpoint (automatically configured, do not modify)
-
-#### Code Reading
-- **`read_source_code`**: Analyzes the specific code file for which tests are being generated
-- **`read_test_code`**: Reads existing tests for the specific file to match your testing patterns
-
-#### Testing Framework Settings
-- **`testing_framework`**: Automatically detected. Possible values: `minitest` or `rspec`
-
-*Note: The following settings depend on your testing framework.*
-
-**For Minitest:**
-- **`test_style`**: Test organization style. Possible options:
-    - `test_block` - `test "does something" do ... end`
-    - `spec` - `it "does something" do ... end`
-    - `unit` - `def test_does_something ... end`
-- **`assertion_style`**: Assertion syntax preference. Possible values:
-    - `assert/refute` - Uses syntax like `assert`, `assert_equal`, `assert_nil`, `refute`, `refute_nil`
-    - `assert/assert_not` - Uses syntax like `assert`, `assert_equal`, `assert_nil`, `assert_not`, `assert_not_equl`, `assert_not_nil`
-    - `must/wont` - `value.must_equal`, `value.must_be_instance_of`, `value.must_raise`, `value.wont_equal`, `value.wont_be_instance_of`, `value.wont_raise`
-
-**For RSpec:**
-- **`describe_style`**: Include describe blocks. Possible values: `true`, `false`
-- **`context_style`**: Context block style. Possible values: `context`, `describe`
-- **`it_style`**: Example block style. Possible values: `it`, `specify`
-- **`before_style`**: Setup block style. Possible values: `before`, `setup`
-- **`after_style`**: Teardown block style. Possible values: `after`, `teardown`
-- **`let_style`**: Use let helpers. Possible values: `true`, `false`
-- **`subject_style`**: Use subject helpers. Possible values: `true`, `false`
-
-#### Authentication Methods
-Supported authentication types:
-- **`session`**: Session-based authentication
-- **`devise`**: Devise gem integration
-- **`jwt`**: JSON Web Token authentication
-- **`token_auth`**: Token-based authentication
-- **`basic_auth`**: HTTP Basic Authentication
-- **`oauth`**: OAuth authentication
-- **`headers`**: Custom header authentication
-- **`custom`**: Custom authentication logic
-
-#### Mock and Factory Libraries
-- **`mock_library`**: Mock library preference
-    - **For Minitest**: `minitest/mock`, `mocha`, `nil`
-    - **For RSpec**: `rspec-mocks`, `mocha`, `flexmock`, `nil`
-- **`http_mock_library`**: HTTP mocking library. Possible values: `webmock`, `vcr`, `httparty`, `nil`
-- **`factory_library`**: Factory library preference. Possible values: `factory_bot`, `factory_girl`, `fabrication`, `fabricator`, `fixtures`, `active_record`
-
-## Configuration Examples
-
-### Minitest with FactoryBot Setup
+This creates `config/initializers/tng.rb`:
 
 ```ruby
-# config/initializers/tng.rb
 Tng.configure do |config|
+  # Get your API key from https://app.tng.sh/
   config.api_key = ENV["TNG_API_KEY"]
-  config.base_url = "https://app.tng.sh/"
-  
-  config.read_source_code = true
-  config.read_test_code = true
-  
-  config.testing_framework = "minitest"
-  config.test_style = "test_block"
-  config.assertion_style = "assert/refute"
-  config.setup_style = true
-  config.teardown_style = false
-  
-  config.mock_library = "minitest/mock"
-  config.http_mock_library = "webmock"
-  config.factory_library = "factory_bot"
-  
-  config.authentication_enabled = true
-  config.authentication_methods = [
-    {
-      method: "authenticate_user!",
-      file_location: "app/controllers/application_controller.rb",
-      auth_type: "session"
-    }
-  ]
+
+  # API endpoint (do not modify unless instructed)
+  config.base_url = ENV["API_BASE_URI"] || "https://app.tng.sh/"
 end
 ```
 
-### RSpec with FactoryBot Setup
+### 2. Set Your API Key
 
-```ruby
-# config/initializers/tng.rb
-Tng.configure do |config|
-  config.api_key = ENV["TNG_API_KEY"]
-  config.base_url = "https://app.tng.sh/"
-  
-  config.testing_framework = "rspec"
-  config.assertion_style = "expect"
-  config.describe_style = true
-  config.context_style = "context"
-  config.it_style = "it"
-  config.before_style = "before"
-  config.after_style = "after"
-  config.let_style = true
-  config.subject_style = true
-  
-  config.mock_library = "rspec-mocks"
-  config.http_mock_library = "webmock"
-  config.factory_library = "factory_bot"
-  
-  config.authentication_enabled = true
-  config.authentication_methods = [
-    {
-      method: "authenticate_user!",
-      file_location: "app/controllers/application_controller.rb",
-      auth_type: "devise"
-    }
-  ]
-end
+Add to your `.env` file or export:
+
+```bash
+export TNG_API_KEY=your_api_key_here
 ```
 
-### API-Only Application with Token Authentication
+Get your API key from [https://app.tng.sh/](https://app.tng.sh/)
 
-```ruby
-# config/initializers/tng.rb
-Tng.configure do |config|
-  config.api_key = ENV["TNG_API_KEY"]
-  config.base_url = "https://app.tng.sh/"
-  
-  config.read_source_code = true
-  config.read_test_code = true
-  
-  config.testing_framework = "minitest"
-  config.test_style = "test_block"
-  config.assertion_style = "assert/refute"
-  
-  config.mock_library = "minitest/mock"
-  config.http_mock_library = "webmock"
-  config.factory_library = "fixtures"
-  
-  config.authentication_enabled = true
-  config.authentication_methods = [
-    {
-      method: "authenticate_via_token!",
-      file_location: "app/controllers/application_controller.rb",
-      auth_type: "headers"
-    }
-  ]
-end
-```
+### 3. Start Using TNG
 
-### Multiple Authentication Methods
+```bash
+# Interactive mode (recommended)
+bundle exec tng
 
-```ruby
-# config/initializers/tng.rb
-Tng.configure do |config|
-  config.api_key = ENV["TNG_API_KEY"]
-  config.base_url = "https://app.tng.sh/"
-  config.testing_framework = "rspec"
-  config.assertion_style = "expect"
-  config.let_style = true
-  
-  config.mock_library = "rspec-mocks"
-  config.http_mock_library = "webmock"
-  config.factory_library = "factory_bot"
-  
-  config.authentication_enabled = true
-  config.authentication_methods = [
-    {
-      method: "authenticate_user!",
-      file_location: "app/controllers/application_controller.rb",
-      auth_type: "session"
-    },
-    {
-      method: "authenticate_api_user!",
-      file_location: "app/controllers/api/base_controller.rb",
-      auth_type: "token_auth"
-    }
-  ]
-  
-  config.authorization_library = "pundit"
-end
+# Or use direct commands
+bundle exec tng --file app/models/user.rb --clones
 ```
 
-## Advanced Configuration
+## Usage
 
-### Custom Authentication Setup
+### Interactive Mode (TUI)
 
-For applications with custom authentication logic that doesn't fit standard patterns:
+The most powerful way to use TNG:
 
-```ruby
-config.authentication_methods = [
-  {
-    method: "verify_custom_auth!",
-    file_location: "app/controllers/concerns/custom_auth.rb",
-    auth_type: "custom"
-  }
-]
+```bash
+bundle exec tng
 ```
 
-#### Rails API Application
+**Interactive Features:**
+- 📁 **Browse** your application structure
+- 🧪 **Generate Tests** for specific methods
+- 🔍 **Audit** methods for issues and improvements
+- 🔬 **Trace** symbolic execution paths
+- 📊 **Check Duplicates** across your codebase
+- 💀 **Find Dead Code** in files
+- 📈 **View Stats** and usage metrics
 
-```ruby
-config.authentication_enabled = true
-config.authentication_methods = [
-  {
-    method: "authenticate_with_token",
-    file_location: "app/controllers/application_controller.rb",
-    auth_type: "jwt"
-  }
-]
-config.factory_library = "fixtures"  # Often simpler for API apps
-```
+### Command Line Interface
 
-#### Multi-Tenant Application
+#### Test Generation
 
-```ruby
-config.authentication_methods = [
-  {
-    method: "authenticate_tenant!",
-    file_location: "app/controllers/application_controller.rb",
-    auth_type: "custom"
-  },
-  {
-    method: "authenticate_user!",
-    file_location: "app/controllers/application_controller.rb",
-    auth_type: "devise"
-  }
-]
+```bash
+# Generate test for a specific method
+bundle exec tng --file app/controllers/users_controller.rb --method index
+
+# Short form
+bundle exec tng -f users_controller.rb -m show
+
+# Works from subdirectories (auto-detection)
+bundle exec tng users_controller.rb index
 ```
 
-#### Legacy Application with Mixed Authentication
+**Supported File Types:**
+Controllers, Models, Services, Jobs, Helpers, Lib, Policies, Presenters, Mailers, Serializers, Decorators, Forms, Queries, Channels, GraphQL (Resolvers, Types, Mutations, Loaders, Schemas), and more.
 
-```ruby
-config.authentication_methods = [
-  {
-    method: "authenticate_admin!",
-    file_location: "app/controllers/admin/base_controller.rb",
-    auth_type: "basic_auth"
-  },
-  {
-    method: "authenticate_user!",
-    file_location: "app/controllers/application_controller.rb",
-    auth_type: "session"
-  },
-  {
-    method: "authenticate_api_key!",
-    file_location: "app/controllers/api/v1/base_controller.rb",
-    auth_type: "headers"
-  }
-]
+#### Code Audit
+
+Analyze code for security, performance, and best practices:
+
+```bash
+# Audit a specific method
+bundle exec tng --file app/services/payment_service.rb --method process_payment --audit
+
+# Interactive audit mode
+bundle exec tng -f payment_service.rb -m process_payment -a
 ```
 
-## Usage Patterns
+**Audit Checks:**
+- Security vulnerabilities
+- Performance bottlenecks
+- Code smells
+- Best practice violations
+- Rails-specific patterns
 
-### Interactive Mode
+#### Symbolic Trace
 
-The recommended way to use TNG for beginners and exploratory testing:
+Visualize execution paths and generate Mermaid diagrams:
 
 ```bash
-bundle exec tng
+# Trace a method's execution flow
+bundle exec tng --file app/models/order.rb --method calculate_total --trace
+
+# Short form
+bundle exec tng -f order.rb -m calculate_total -t
 ```
 
-This launches an interactive session where you can:
-- Browse your application structure
-- Select files to generate tests for
-- Preview generated tests before saving
-- Adjust configuration on the fly
+**Trace Features:**
+- Control flow visualization
+- Conditional path analysis
+- Loop detection
+- Method call chains
+- Mermaid diagram generation
+
+#### Clone Detection
 
-### Method-Specific Testing
+Find duplicate code with 3 levels of detection:
 
-TNG focuses on precise, method-level test generation:
+```bash
+# Check for all types of clones
+bundle exec tng --file app/services/pricing_service.rb --clones
 
-- **Select specific methods** from 20+ file types including controllers, models, services, jobs, helpers, lib, policies, presenters, mailers, GraphQL components, and more
-- **Interactive browsing** with search and filter capabilities
-- **Focused test generation** for individual methods only
-- **No bulk generation** - intentionally designed for precision
+# Specific detection level
+bundle exec tng --file app/services/pricing_service.rb --clones --level=1
+bundle exec tng --file app/services/pricing_service.rb --clones --level=2
+bundle exec tng --file app/services/pricing_service.rb --clones --level=3
 
-Use `bundle exec tng --help` for more options.
+# Short form
+bundle exec tng -f pricing_service.rb -c
+```
 
-### Direct Mode (for Developers)
+**Detection Levels:**
+- **Level 1 (Token)** - Exact or near-exact duplicates (copy-paste detection)
+- **Level 2 (Structural)** - Same AST structure with different names
+- **Level 3 (Fuzzy)** - Similar logic with variations (up to 20% difference)
 
-For experienced developers who want quick, command-line test generation:
+#### Dead Code Detection
+
+Identify unreachable code and unused elements:
 
 ```bash
-# Generate test for specific method using file path
-bundle exec tng app/controllers/users_controller.rb index
+# Detect dead code in a file
+bundle exec tng --file app/models/user.rb --deadcode
 
-# Short form using shortcuts
-bundle exec tng f=users_controller.rb m=show
+# Short form
+bundle exec tng -f user.rb -d
 
-# Full parameter names
-bundle exec tng --file=app/models/user.rb --method=validate
+# JSON output for CI/CD
+bundle exec tng -f user.rb --deadcode --json
+```
 
-# Works from subdirectories (auto-detection)
-bundle exec tng users_controller.rb index
+**Dead Code Types:**
+- **Unreachable Code** - Code after `return`, `raise`, `exit`, etc.
+- **Unused Variables** - Local variables assigned but never used
+- **Unused Private Methods** - Private methods never called
+- **Unused Parameters** - Method parameters never referenced
+
+### JSON Output Mode
+
+Get machine-readable output for CI/CD integration:
 
-# Mixed parameter order
-bundle exec tng m=index f=app/controllers/users_controller.rb
+```bash
+# Any command with --json flag
+bundle exec tng --file app/models/user.rb --clones --json
+bundle exec tng --file app/services/payment.rb --deadcode --json
+bundle exec tng --file app/controllers/api_controller.rb --trace --json
 ```
 
-**Direct Mode Features:**
-- **Automatic file type detection** - No need to specify `-t controller/model/service`
-- **Flexible file path resolution** - Works with full paths or just filenames
-- **Multiple syntax formats** - Use `f=` shortcuts or `--file=` full parameters
-- **Smart path finding** - Automatically searches Rails directories
+## Advanced Features
+
+### Method-Specific Analysis
+
+TNG focuses on precise, method-level analysis:
+
+- **Select specific methods** from any file type
+- **Interactive browsing** with search and filter
+- **Focused generation** for individual methods
+- **No bulk generation** - designed for precision
+
+### File Type Auto-Detection
+
+No need to specify file types - TNG automatically detects:
+
+```bash
+# All of these work automatically
+bundle exec tng users_controller.rb index
+bundle exec tng user.rb validate_email
+bundle exec tng payment_service.rb process
+bundle exec tng user_mailer.rb welcome_email
+bundle exec tng user_resolver.rb find_user
+```
 
 ### Debug Mode
 
-For troubleshooting configuration or generation issues:
+Enable detailed logging for troubleshooting:
 
 ```bash
-# Interactive mode with debug on
 DEBUG=1 bundle exec tng
+DEBUG=1 bundle exec tng -f users_controller.rb -m index
+```
+
+## Examples
+
+### Example 1: Find Duplicate Code
+
+```bash
+$ bundle exec tng --file app/services/pricing_service.rb --clones
+
+🔍 Clone Detection Results
 
-# Direct mode with debug
-DEBUG=1 bundle exec tng app/controllers/users_controller.rb index
+Level 1 (Token): 2 matches found
+  ├─ Lines 45-52 ↔ Lines 78-85 (8 lines, exact match)
+  └─ Lines 120-127 ↔ Lines 156-163 (8 lines, exact match)
+
+Level 2 (Structural): 1 match found
+  └─ Lines 200-215 ↔ Lines 240-255 (16 nodes, complexity: 85)
+
+Level 3 (Fuzzy): 1 match found
+  └─ Lines 300-320 ↔ Lines 350-370 (similar logic, 15% variation)
 ```
 
-### Help and Options
+### Example 2: Detect Dead Code
 
 ```bash
-bundle exec tng --help              # Show help message
-bundle exec tng -h                  # Short help
+$ bundle exec tng --file app/models/user.rb --deadcode
+
+💀 Dead Code Detection Results
+
+[Unreachable Code] Line 42: Code follows terminal statement
+   42:   puts "This will never execute"
+
+[Unused Variable] Line 67: Variable 'temp' is assigned but never used
+   67:   temp = calculate_something
+
+[Unused Method] Line 120: Private method 'unused_helper' is never used
+   120:   def unused_helper
+
+[Unused Parameter] Line 85: Parameter 'options' is never used
+   85:   def process(data, options)
 ```
 
-## Troubleshooting
+### Example 3: Trace Execution Flow
 
-### Configuration Issues
+```bash
+$ bundle exec tng --file app/models/order.rb --method calculate_total --trace
+
+🔬 Symbolic Trace Results
+
+Execution Paths: 3
+Complexity Score: 12
+
+Path 1: items.empty? → return 0
+Path 2: discount_code.present? → apply_discount → calculate_tax → total
+Path 3: !discount_code.present? → calculate_tax → total
 
-#### API Key Problems
+[Mermaid diagram saved to: trace_order_calculate_total.md]
+```
+
+## CLI Reference
+
+### Flags
+
+| Flag | Short | Description |
+|------|-------|-------------|
+| `--file` | `-f` | Target file path |
+| `--method` | `-m` | Method name to analyze |
+| `--audit` | `-a` | Run audit mode |
+| `--trace` | `-t` | Run symbolic trace mode |
+| `--clones` | `-c` | Run clone detection |
+| `--deadcode` | `-d` | Run dead code detection |
+| `--level` | `-l` | Clone detection level (1, 2, 3, or all) |
+| `--json` | | Output as JSON |
+| `--help` | `-h` | Show help message |
+
+### Examples
+
+```bash
+# Test generation
+bundle exec tng -f users_controller.rb -m index
+
+# Code audit
+bundle exec tng -f payment_service.rb -m process -a
+
+# Symbolic trace
+bundle exec tng -f order.rb -m calculate_total -t
+
+# Clone detection (all levels)
+bundle exec tng -f pricing_service.rb -c
+
+# Clone detection (specific level)
+bundle exec tng -f pricing_service.rb -c -l 2
+
+# Dead code detection
+bundle exec tng -f user.rb -d
+
+# JSON output
+bundle exec tng -f user.rb -c --json
+```
+
+## Troubleshooting
+
+### API Key Issues
 
 **Error: "Invalid API key"**
 - Verify your API key from https://app.tng.sh/
-- Check environment variable: `echo $TNG_API_KEY`
-- Ensure no extra spaces in `.env` file: `TNG_API_KEY=your_key_here`
+- Check: `echo $TNG_API_KEY`
+- Ensure no extra spaces in `.env`: `TNG_API_KEY=your_key_here`
 
 **Error: "API key not found"**
 - Set environment variable: `export TNG_API_KEY=your_key`
 - Or add to `.env` file: `TNG_API_KEY=your_key`
-- Restart Rails server after changing environment variables
+- Restart Rails server after changes
 
-#### Configuration Validation
+### Configuration Issues
 
 **Error: "Invalid configuration"**
-- Run configuration check: `rails console` then `Tng.configuration`
-- Verify all required settings are present
+- Run: `rails console` then `Tng.configuration`
+- Verify `config/initializers/tng.rb` exists
 - Check for typos in configuration file
 
-**Poor Test Quality**
-- Verify authentication methods are correctly configured
-- Check factory library setting matches your setup
-- Ensure `read_source_code` and `read_test_code` are enabled
-- Review testing framework settings match your project
-
-#### Authentication Configuration Issues
-
-**Tests don't include authentication**
-- Verify `authentication_enabled = true`
-- Check authentication methods are correctly specified
-- Ensure file paths exist: `ls app/controllers/application_controller.rb`
-- Verify method names exist in specified files
-
-**Authentication tests fail**
-- Check auth method names match your application
-- Verify file locations are correct
-- Ensure auth_type matches your authentication pattern
-
 ### Generation Issues
 
-#### No Tests Generated
-
-**Check these common issues:**
-1. File path is correct: `ls app/controllers/users_controller.rb`
-2. File contains valid Ruby code
-3. Configuration is valid
-4. API key is working
-5. Internet connection is available
+**No tests generated:**
+1. Verify file path: `ls app/controllers/users_controller.rb`
+2. Check file contains valid Ruby code
+3. Verify API key is working
+4. Check internet connection
 
-#### Generated Tests Are Generic
-
-**Common causes:**
-- Authentication not properly configured
-- Factory library setting doesn't match your setup
-- `read_source_code` or `read_test_code` disabled
-- File analysis failed (check DEBUG mode)
+**Poor test quality:**
+- Ensure you're using the latest version
+- Try audit mode for better insights
+- Check file is properly formatted
 
 ### Debug Mode
 
-Enable debug mode to get detailed information:
+Enable debug output for detailed information:
 
 ```bash
-DEBUG=1 bundle exec tng app/controllers/your_controller.rb method_name
+DEBUG=1 bundle exec tng -f users_controller.rb -m index
 ```
 
 Debug output includes:
-- API request/response information
-
-### Getting Help
-
-If you're still experiencing issues: Contact the gem maintainers or open a GitHub issue for support
+- API request/response details
+- File analysis results
+- Configuration validation
+- Error stack traces
+
+## What's New in v0.4.8
+
+### New Features
+- ✨ **Level 3 Fuzzy Clone Detection** - Find similar code with variations
+- ✨ **Dead Code Detection** - Identify unreachable code and unused elements
+- ✨ **Simplified Configuration** - Only API key required to get started
+- ✨ **Enhanced Clone Detection** - 3 levels of duplicate detection
+- ✨ **Improved UI** - Better visualization of results
+
+### Improvements
+- ⚡ Faster file analysis with optimized Rust parsers
+- 🎨 Better error messages and user feedback
+- 📊 Enhanced reporting for all analysis modes
+- 🔧 Auto-detection of file types and test frameworks
+
+## Getting Help
+
+If you're experiencing issues:
+- Check the troubleshooting section above
+- Enable debug mode: `DEBUG=1 bundle exec tng`
+- Contact support at https://app.tng.sh/
+- Open a GitHub issue for bug reports
 
 ## License
 

data/Rakefile

@@ -75,9 +75,17 @@ task :redo do
       # Code sign the bundles on macOS
       if RUBY_PLATFORM.include?("darwin")
         puts "🔐 Signing bundles..."
+        system("xattr -dr com.apple.quarantine binaries/ || true")
+
+        # Sign tng bundle
         system("codesign --force --sign - #{source_file}")
         system("codesign --force --sign - #{File.join(destination_dir, binary_name)}")
 
+        # Sign go-ui binaries if present
+        Dir.glob("binaries/go-ui-darwin-*").each do |binary|
+          system("codesign --force --sign - #{binary}")
+        end
+
         # Also sign the gem installation if it exists
         ruby_version = RUBY_VERSION.split(".")[0..1].join(".")
         gem_bundle = File.expand_path("~/.local/share/mise/installs/ruby/#{RUBY_VERSION}/lib/ruby/gems/#{ruby_version}.0/gems/tng-*/binaries/tng.bundle")

data/bin/tng

@@ -48,6 +48,10 @@ class CLI
     example "Duplicate Detection:", ""
     example "  bundle exec tng app/services/pricing_service.rb --clones", ""
     example "  bundle exec tng --file=users_controller.rb --clones --level=2", ""
+    example ""
+    example "Dead Code Detection:", ""
+    example "  bundle exec tng app/models/user.rb --deadcode", ""
+    example "  bundle exec tng --file=app/services/auth_service.rb -d", ""
   end
 
   option :file do
@@ -68,10 +72,16 @@ class CLI
     desc "Run in clone detection mode (find code duplication)"
   end
 
+  flag :deadcode do
+    short "-d"
+    long "--deadcode"
+    desc "Run in dead code detection mode (unreachable code, unused variables)"
+  end
+
   option :level do
     short "-l"
     long "--level=LEVEL"
-    desc "Analysis level: 1 (Token), 2 (Structural), all (Both)"
+    desc "Analysis level: 1 (Token), 2 (Structural), 3 (Fuzzy), all (All levels)"
   end
 
   flag :audit do
@@ -140,6 +150,8 @@ class CLI
       handle_fix_command
     elsif params[:trace] && params[:file]
       run_direct_trace
+    elsif params[:deadcode] && params[:file]
+      run_dead_code_detection
     elsif params[:file]
       run_direct_generation
     else
@@ -153,7 +165,10 @@ class CLI
       return unless check_configuration
 
       check_system_status
+      # puts "DEBUG: Verifying authentication..."
       return unless check_authentication
+      # puts "DEBUG: Authentication verified."
+
 
       clear_screen
       @go_ui.show_banner(Tng::VERSION)
@@ -181,6 +196,8 @@ class CLI
         normalized << "--fix"
       when /^(?:--)?(clones|c)$/
         normalized << "--clones"
+      when /^(?:--)?(deadcode|d)$/
+        normalized << "--deadcode"
       when /^(?:--)?(level|l)=(.+)$/
         normalized << "--level=#{::Regexp.last_match(2)}"
       when /^(help|h)=(.+)$/
@@ -242,6 +259,8 @@ class CLI
         handle_trace_method
       when "clones"
         handle_clone_detection
+      when "deadcode"
+        handle_dead_code_detection_menu
       when "stats"
         user_stats
       when "about"
@@ -506,6 +525,35 @@ class CLI
     @go_ui.show_audit_results(audit_data, "issues")
   end
 
+  def run_dead_code_detection
+    file_path = params[:file]
+    unless File.exist?(file_path)
+      puts @pastel.red("Error: File '#{file_path}' not found.")
+      return
+    end
+
+    absolute_path = File.expand_path(file_path)
+    json_output = params[:json] || false
+
+    begin
+      # Always get JSON from Rust for flexibility
+      result = Tng.detect_dead_code(absolute_path, true)
+
+      if json_output
+        puts result
+      else
+        if @go_ui
+          @go_ui.show_dead_code_results(absolute_path, result)
+        else
+          # Fallback to text output
+          puts Tng.detect_dead_code(absolute_path, false)
+        end
+      end
+    rescue => e
+      puts @pastel.red("Error detecting dead code: #{e.message}")
+    end
+  end
+
   # Placeholder methods for other component types
   def audit_model_method
     models = nil
@@ -1470,18 +1518,129 @@ class CLI
          choice = files.find { |f| f[:name] == selected }
          next unless choice
 
-         methods = extract_other_methods(choice)
-         if methods.empty?
-             @go_ui.show_no_items("methods in #{choice[:name]}")
-             next
-         end
+         # For dead code, we don't need to select a method, just the file.
+         # But this helper yields (file_choice, method_choice).
+         # We might need a simpler selector for dead code if it's file-based only.
+         # Re-using method selector for now if we want per-method, but dead code is usually per-file.
 
-         m_items = methods.map { |m| { name: m[:name], path: choice[:name] } }
-         m_selected = @go_ui.show_list_view("Select Method to #{action_name}", m_items)
-         next if m_selected == "back"
+         # Actually, dead code analysis is whole-file.
+         # So we should probably just return the file choice.
 
-         m_choice = methods.find { |m| m[:name] == m_selected }
-         yield(choice, m_choice)
+         # Let's implement specific helpers for dead code that just pick files.
+      end
+  end
+
+  def handle_dead_code_detection_menu
+    # Pick a file type first to narrow down
+    choice = @go_ui.show_test_type_menu("deadcode")
+    return if choice == "back"
+
+    case choice
+    when "controller"
+      detect_dead_code_for_type("app/controllers", Tng::Analyzers::Controller)
+    when "model"
+      detect_dead_code_for_type("app/models", Tng::Analyzers::Model)
+    when "service"
+      # Service analyzer is a bit different, it scans app/services usually
+      detect_dead_code_for_service
+    when "other"
+      detect_dead_code_for_other
+    end
+  end
+
+  def detect_dead_code_for_type(dir, analyzer_class)
+    files = nil
+    @go_ui.show_spinner("Analyzing files in #{dir}...") do
+      files = analyzer_class.files_in_dir(dir).map do |file|
+        relative_path = file[:path].gsub(%r{^.*#{dir}/}, "").gsub(".rb", "")
+        namespaced_name = relative_path.split("/").map(&:camelize).join("::")
+        { name: namespaced_name, path: file[:path] }
+      end
+      { success: true, message: "Found #{files.length} files" }
+    end
+
+    return @go_ui.show_no_items(dir) if files.empty?
+
+    items = files.map { |f| { name: f[:name], path: f[:path] } }
+
+    loop do
+      selected = @go_ui.show_list_view("Select File to Analyze", items)
+      return if selected == "back"
+
+      choice = files.find { |f| f[:name] == selected }
+      next unless choice
+
+      # Run detection on the file
+      run_dead_code_detection_interactive(choice[:path])
+    end
+  end
+
+  def detect_dead_code_for_service
+     services = nil
+     @go_ui.show_spinner("Analyzing services...") do
+       services = Tng::Analyzers::Service.files_in_dir.map do |file|
+         relative_path = file[:path].gsub(%r{^.*app/services?/}, "").gsub(".rb", "")
+         namespaced_name = relative_path.split("/").map(&:camelize).join("::")
+         { name: namespaced_name, path: file[:path] }
+       end
+       { success: true, message: "Found #{services.length} services" }
+     end
+
+     return @go_ui.show_no_items("services") if services.empty?
+
+     items = services.map { |s| { name: s[:name], path: s[:path] } }
+
+     loop do
+       selected = @go_ui.show_list_view("Select Service to Analyze", items)
+       return if selected == "back"
+
+       choice = services.find { |s| s[:name] == selected }
+       next unless choice
+
+       run_dead_code_detection_interactive(choice[:path])
+     end
+  end
+
+  def detect_dead_code_for_other
+      files = nil
+      @go_ui.show_spinner("Analyzing other files...") do
+        files = Tng::Analyzers::Other.files_in_dir.map do |file|
+          relative_path = file[:relative_path].gsub(".rb", "")
+          namespaced_name = relative_path.split("/").map(&:camelize).join("::")
+          { name: namespaced_name, path: file[:path], type: file[:type] }
+        end
+        { success: true, message: "Found #{files.length} other files" }
+      end
+
+      return @go_ui.show_no_items("other files") if files.empty?
+
+      items = files.map { |f| { name: f[:name], path: f[:path] } }
+
+      loop do
+        selected = @go_ui.show_list_view("Select File to Analyze", items)
+        return if selected == "back"
+
+        choice = files.find { |f| f[:name] == selected }
+        next unless choice
+
+        run_dead_code_detection_interactive(choice[:path])
+      end
+  end
+
+  def run_dead_code_detection_interactive(path)
+      @go_ui.show_spinner("Detecting dead code...") do
+         # Just a visual delay or setup if needed
+         sleep(0.5)
+         { success: true, message: "Analysis complete" }
+      end
+
+      # Reuse the CLI logic but bypass params
+      absolute_path = File.expand_path(path)
+      begin
+        result = Tng.detect_dead_code(absolute_path, true)
+        @go_ui.show_dead_code_results(absolute_path, result)
+      rescue => e
+        @go_ui.display_error("Error detecting dead code: #{e.message}")
       end
   end
 end

data/lib/generators/tng/install_generator.rb

@@ -34,6 +34,7 @@ module Tng
           return unless Rails.env.development?
 
           Tng.configure do |config|
+            # Get your API key from https://app.tng.sh/
             config.api_key = ENV["TNG_API_KEY"]
             config.base_url = ENV["API_BASE_URI"] || "https://app.tng.sh/"
 

data/lib/tng/ui/go_ui_session.rb

@@ -272,6 +272,35 @@ module Tng
         _cleanup_temp_file(input_path)
       end
 
+      def show_dead_code_results(file_path, results_json)
+        parsed = JSON.parse(results_json)
+
+        # Rust returns {"file": "...", "dead_code": [...]}
+        issues = parsed["dead_code"] || []
+
+        data = {
+          file: file_path,
+          dead_code: issues.map do |issue|
+            {
+              type: issue["type"],
+              line: issue["line"],
+              message: issue["message"],
+              code: issue["code"]
+            }
+          end
+        }
+
+        input_path = _create_temp_file("go_ui_dead_code", ".json")
+        File.write(input_path, JSON.generate(data))
+
+        system(@binary_path, "deadcode", "--file", input_path)
+      rescue StandardError => e
+        puts "Dead code results error: #{e.message}"
+      ensure
+        _cleanup_temp_file(input_path)
+      end
+
+
       # Show authentication error
       # @param message [String] Error message to display
       def show_auth_error(message = "Authentication failed")
@@ -346,7 +375,8 @@ module Tng
             { cmd: "bundle exec tng --file=FILE --method=METHOD", desc: "Direct test generation" },
             { cmd: "bundle exec tng --file=FILE --method=METHOD --audit", desc: "Direct audit mode" },
             { cmd: "bundle exec tng --file=FILE --method=METHOD --trace", desc: "Symbolic trace mode" },
-            { cmd: "bundle exec tng --file=FILE --clones", desc: "Check for code duplicates" }
+            { cmd: "bundle exec tng --file=FILE --clones", desc: "Check for code duplicates" },
+            { cmd: "bundle exec tng --file=FILE --deadcode", desc: "Run dead code detection" }
           ],
           features: [
             "Controllers, Models, Services",
@@ -355,6 +385,7 @@ module Tng
             "Code audit for issues & behaviors",
             "Symbolic execution traces",
             "Duplicate code detection (Clones)",
+            "Dead code detection (Rust-powered)",
             "Searchable method lists"
           ],
           options: [
@@ -364,15 +395,17 @@ module Tng
             { flag: "--audit", desc: "Run audit mode instead of test generation" },
             { flag: "--trace", desc: "Run symbolic trace mode" },
             { flag: "--clones", desc: "Run clone detection mode" },
-            { flag: "--level=1|2|all", desc: "Set clone detection level (default: all)" }
+            { flag: "--level=1|2|3|all", desc: "Set clone detection level (default: all)" },
+            { flag: "--deadcode", desc: "Run dead code detection" }
           ],
           how_to: [
             "Run 'bundle exec tng' for interactive mode",
             "Run 'tng [file] --clones' for duplicate detection",
+            "Run 'tng [file] --deadcode' for dead code analysis",
             "Select Controller, Model, or Service to start",
             "Choose a method to generate/audit or select 'Check Duplicates'"
           ],
-          footer: "Happy testing! "
+          footer: ""
         }
 
         system(@binary_path, "help-box", "--version", version, "--data", JSON.generate(help_data))
@@ -478,8 +511,14 @@ module Tng
           File.expand_path("binaries/#{binary_name}", Dir.pwd)
         ]
 
+        # puts "DEBUG: Searching for binary #{binary_name} in:"
+        # binary_paths.each { |p| puts "  - #{p}" }
+
         binary_paths.each do |path|
-          return path if File.exist?(path) && File.executable?(path)
+          if File.exist?(path) && File.executable?(path)
+            # puts "DEBUG: Found binary at #{path}"
+            return path
+          end
         end
 
         raise "go-ui binary not found. Searched: #{binary_paths.join(", ")}"

data/lib/tng/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Tng
-  VERSION = "0.4.7"
+  VERSION = "0.4.8"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: tng
 version: !ruby/object:Gem::Version
-  version: 0.4.7
+  version: 0.4.8
 platform: ruby
 authors:
 - ralucab
@@ -222,7 +222,7 @@ post_install_message: "┌ TNG ────────────────
   \                                                            │\n│  • bundle exec
   tng --help  - Show help information                 │\n│                                                                    │\n│
   \ \U0001F4A1 Generate tests for individual methods with precision            │\n└────────────────────────────────────────────────────────────
-  v0.4.7 ┘\n"
+  v0.4.8 ┘\n"
 rdoc_options: []
 require_paths:
 - lib