n2b 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 58382cb632f67e6ad3ca031c71a2c53bd5cd477ea32963d89f0d253d8b43bbeb
-  data.tar.gz: facb990aad05d93cac662fdbf60075ad3606dd43083f408a8e0d60d5940df359
+  metadata.gz: d512a4b43acc8a3adac6fe3fd60d05605abef697b36e0beb2e896371c6ae94c0
+  data.tar.gz: 140274359582046b03b89521d143e7efc498c07ee85c6cd200de821191b0b0db
 SHA512:
-  metadata.gz: 8dd53c35513bf7071c5aecb7f724ebc44f522a166ef1ca8dc4aecfda3f9cd801dd7d85bce6762a4fc8bd5e1a98aa87eaa9e8080db3302a17d5875f8010b90867
-  data.tar.gz: 866846f2c517fe7dcee27172640151b1d6e567161b473a7c5a39c3894df15ea25b43e2278b24fd783f93c5eac8f507e7d331a85ef5fc5084990f89c227c19485
+  metadata.gz: '0184eb2ae93e21a1a389f7445c5e1d3532f645f5164df29ba7acc77ce67e163b8a273767aadc7a3b1ccab8483ae62d7e75b691331cb9145f4075a5a3aa3777ae'
+  data.tar.gz: d12e12c75dc2e6b161fb9f169de0a2dd7a8760bdcdf49b915c217407937516cffca31fb5649c5b65e33b81f7c02d688c7695c9c7cf4f5c638d837756c3ce97e5

data/README.md

@@ -1,29 +1,92 @@
-# N2B - Natural Language to Bash & Ruby
+# N2B - AI-Powered Code Analysis & Jira Integration
 
 [![Gem Version](https://badge.fury.io/rb/n2b.svg)](https://badge.fury.io/rb/n2b)
 
-N2B (Natural Language to Bash & Ruby) is a Ruby gem that leverages AI to convert natural language instructions into bash commands and Ruby code.
+**Transform your development workflow with intelligent code analysis and seamless Jira integration.** N2B is an AI-powered development tool that revolutionizes code review, requirements compliance, and project management through automated analysis and smart ticket integration.
 
-## Features
+## 🚀 **Key Features**
 
-- **🤖 Natural Language to Commands**: Convert natural language to bash commands
-- **💎 Ruby Code Generation**: Generate Ruby code from natural language instructions
-- **🔍 AI-Powered Diff Analysis**: Analyze git/hg diffs with comprehensive code review
-- **📋 Requirements Compliance**: Check if code changes meet specified requirements
-- **🧪 Test Coverage Assessment**: Evaluate test coverage for code changes
-- **🌿 Branch Comparison**: Compare changes against any branch (main/master/default)
-- **🛠️ VCS Support**: Full support for both Git and Mercurial repositories
-- **📊 Errbit Integration**: Analyze Errbit errors and generate detailed reports
-- **🎫 Scrum Tickets**: Create formatted Scrum tickets from errors
+### 🎯 **Smart Jira Integration**
+- **Automated Ticket Analysis**: Fetch requirements from Jira tickets and analyze code changes against them
+- **Intelligent Updates**: Post beautifully formatted analysis results directly to Jira with collapsible sections
+- **Requirements Extraction**: Automatically identify acceptance criteria, tasks, and requirements from tickets and comments
+- **Real-time Feedback**: Get instant compliance checking and implementation guidance
 
-### 🆕 **New in v0.4.0: Flexible Model Configuration**
+### 🔍 **AI-Powered Code Analysis**
+- **Context-Aware Diff Review**: Intelligent analysis of git/hg changes with comprehensive insights
+- **Requirements Compliance**: Automated verification against project requirements and acceptance criteria
+- **Test Coverage Assessment**: Evaluate test completeness and suggest improvements
+- **Security & Quality Insights**: Identify potential issues, risks, and improvement opportunities
 
-- **🎯 Multiple LLM Providers**: Claude, OpenAI, Gemini, OpenRouter, Ollama
-- **🔧 Custom Models**: Use any model name - fine-tunes, beta models, custom deployments
-- **📋 Suggested Models**: Curated lists of latest models with easy selection
-- **🚀 Latest Models**: OpenAI O3/O4 series, Gemini 2.5, updated OpenRouter models
-- **🔄 Backward Compatible**: Existing configurations continue working seamlessly
-- **⚡ No Restrictions**: Direct API model names accepted without validation
+### 🤖 **Flexible AI Support**
+- **Multiple LLM Providers**: Claude, OpenAI, Gemini, OpenRouter, Ollama
+- **Latest Models**: OpenAI O3/O4 series, Gemini 2.5, Claude Sonnet 4.0
+- **Custom Models**: Support for fine-tuned models, beta releases, and custom deployments
+
+### 💻 **Development Workflow**
+- **Natural Language Commands**: Convert descriptions to executable bash commands
+- **Ruby Code Generation**: Generate Ruby code from natural language instructions
+- **VCS Integration**: Full Git and Mercurial support with branch comparison
+- **Errbit Integration**: Analyze errors and generate actionable reports
+
+## 🎯 **Jira Integration - Get Started in 2 Minutes**
+
+Transform your development workflow with intelligent Jira integration:
+
+### Quick Setup
+
+```bash
+# Install and configure
+gem install n2b
+n2b --advanced-config  # Set up Jira credentials
+
+# Test your connection
+n2b-test-jira
+
+# Analyze code against ticket requirements
+n2b --diff --jira PROJ-123 --jira-update
+```
+
+### What You Get
+
+1. **📥 Smart Ticket Analysis**: Automatically fetches requirements, acceptance criteria, and comments from Jira
+2. **🔍 Intelligent Code Review**: AI analyzes your changes against ticket requirements
+3. **📤 Structured Updates**: Posts beautifully formatted analysis back to Jira with collapsible sections
+4. **✅ Requirements Compliance**: Clear status on what's implemented, partially done, or missing
+
+### Example Workflow
+
+```bash
+# Working on ticket PROJ-123
+git add .
+n2b --diff --jira PROJ-123 --jira-update
+```
+
+**Result**: Your Jira ticket gets updated with a professional analysis comment showing implementation progress, technical insights, and compliance status.
+
+## 🔍 **AI-Powered Code Analysis**
+
+Get comprehensive code review and insights:
+
+```bash
+# Analyze uncommitted changes
+n2b --diff
+
+# Compare against specific branch with requirements
+n2b --diff --branch main --requirements requirements.md
+
+# Full workflow with Jira integration
+n2b --diff --jira PROJ-123 --requirements specs.md
+```
+
+## 🆕 **What's New in v0.5.0**
+
+- **🎯 Full Jira Integration**: Real API integration with ticket fetching and automated updates
+- **📝 Structured Comments**: Beautifully formatted Jira comments with collapsible sections
+- **🔍 Smart Requirements Extraction**: AI identifies requirements from tickets and comments
+- **🧪 Connection Testing**: Built-in `n2b-test-jira` utility for troubleshooting
+- **📋 Permission Validation**: Verifies all required Jira API permissions
+- **⚡ Enhanced Analysis**: Improved code review with better context and insights
 
 ## Installation
 
@@ -31,7 +94,39 @@ N2B (Natural Language to Bash & Ruby) is a Ruby gem that leverages AI to convert
 gem install n2b
 ```
 
-## Usage
+## Quick Start
+
+### 🎯 **For Jira Users** (Most Popular)
+
+```bash
+# Set up Jira integration
+n2b --advanced-config
+
+# Analyze code changes against ticket
+n2b --diff --jira PROJ-123 --jira-update
+```
+
+### 🔍 **For Code Review**
+
+```bash
+# AI-powered diff analysis
+n2b --diff
+
+# Compare against main branch with requirements
+n2b --diff --branch main --requirements specs.md
+```
+
+### 💻 **For Command Generation**
+
+```bash
+# Generate bash commands
+n2b "create a new git repo and push to github"
+
+# Execute commands directly
+n2b -x "backup all .rb files to backup folder"
+```
+
+## Detailed Usage
 
 ### In IRB/Rails Console
 
@@ -232,7 +327,11 @@ Options:
 - `-d` or `--diff`: Analyze git/hg diff with AI-powered code review
 - `-b` or `--branch [BRANCH]`: Compare against specific branch (auto-detects main/master/default)
 - `-r` or `--requirements FILE`: Requirements file for compliance checking
+- `-j` or `--jira TICKET`: Jira ticket ID or URL for context and updates
+- `--jira-update`: Automatically update Jira ticket with analysis (no prompt)
+- `--jira-no-update`: Skip Jira ticket update (analyze only)
 - `-c` or `--config`: Reconfigure the tool
+- `--advanced-config`: Advanced configuration including Jira setup
 - `-h` or `--help`: Display help information
 
 Examples:
@@ -326,6 +425,115 @@ Requirements Evaluation:
 - **Git**: Full support with auto-detection of main/master branches
 - **Mercurial (hg)**: Full support with auto-detection of default branch
 
+## 🎯 Jira Integration
+
+N2B provides seamless integration with Jira for automated ticket analysis and updates.
+
+### Setup
+
+Configure Jira integration using the advanced configuration:
+
+```bash
+n2b --advanced-config
+```
+
+You'll need:
+- **Jira Domain**: Your Atlassian domain (e.g., `company.atlassian.net`)
+- **Email**: Your Jira account email
+- **API Token**: Generate from [Atlassian Account Settings](https://id.atlassian.com/manage-profile/security/api-tokens)
+
+### Required Jira Permissions
+
+Your API token needs these permissions:
+- **Browse Projects** - Access project list
+- **Browse Issues** - Read ticket details
+- **View Comments** - Read ticket comments
+- **Add Comments** - Post analysis results
+
+### Usage
+
+```bash
+# Analyze code changes against Jira ticket requirements
+n2b --diff --jira PROJ-123
+
+# Use full Jira URL
+n2b --diff --jira https://company.atlassian.net/browse/PROJ-123
+
+# Auto-update ticket without prompt
+n2b --diff --jira PROJ-123 --jira-update
+
+# Analyze only (no ticket update)
+n2b --diff --jira PROJ-123 --jira-no-update
+```
+
+### What It Does
+
+1. **Fetches Ticket Details**: Downloads ticket description and comments
+2. **Extracts Requirements**: Automatically identifies requirements, acceptance criteria, and tasks
+3. **Analyzes Code Changes**: Compares your diff against ticket requirements
+4. **Updates Ticket**: Posts structured analysis comment with:
+   - Implementation summary (what you accomplished)
+   - Technical analysis findings
+   - Potential issues and suggestions
+   - Test coverage assessment
+   - Requirements compliance check
+
+### Example Jira Comment
+
+```
+*N2B Code Analysis Report*
+=========================
+
+*Implementation Summary:*
+Implemented user authentication with JWT tokens, password validation,
+and session management as specified in the ticket requirements.
+
+---
+
+*Automated Analysis Findings:*
+
+*Technical Changes:*
+Added authentication middleware, JWT token generation, and password
+hashing with bcrypt. Updated user model with authentication methods.
+
+*Potential Issues/Risks:*
+• No rate limiting on login attempts
+• Password validation could be stronger
+
+*Suggested Improvements:*
+• Add rate limiting middleware
+• Implement password strength requirements
+• Add two-factor authentication support
+
+*Test Coverage Assessment:*
+Good: Basic authentication flow tested. Missing: Edge cases, security
+scenarios, and JWT expiration handling tests.
+
+*Requirements Evaluation:*
+✅ IMPLEMENTED: User login/logout functionality
+✅ IMPLEMENTED: Password hashing and validation
+⚠️ PARTIALLY IMPLEMENTED: Session management (basic implementation)
+❌ NOT IMPLEMENTED: Two-factor authentication
+```
+
+### Testing Jira Connection
+
+Test your Jira API connection and permissions:
+
+```bash
+# Test basic connection
+n2b-test-jira
+
+# Test specific ticket access
+n2b-test-jira PROJ-123
+```
+
+This will verify:
+- Network connectivity to Jira
+- Authentication with your API token
+- Required permissions
+- Specific ticket access (if provided)
+
 n2r in ruby or rails console
 n2r "your question", files:['file1.rb', 'file2.rb'], exception: AnError
 only question is mandatory
@@ -385,6 +593,27 @@ Contributions are welcome! Please feel free to submit a Pull Request.
 
 This project is licensed under the MIT License.
 
+## Version History
+
+### 🚀 **v0.5.0 - Jira Integration & Enhanced Analysis**
+- Full Jira API integration with real ticket fetching and comment posting
+- Structured Jira comments using ADF with collapsible sections
+- Smart requirements extraction from ticket descriptions and comments
+- Built-in connection testing with `n2b-test-jira` utility
+- Enhanced configuration validation and error handling
+
+### 🔧 **v0.4.0 - Flexible Model Configuration**
+- Multiple LLM providers: Claude, OpenAI, Gemini, OpenRouter, Ollama
+- Custom model support for fine-tunes and beta releases
+- Latest models: OpenAI O3/O4 series, Gemini 2.5, Claude Sonnet 4.0
+- Backward compatible configuration system
+
+### 🔍 **v0.3.0 - AI-Powered Diff Analysis**
+- Git/Mercurial diff analysis with context extraction
+- Requirements compliance checking
+- Test coverage assessment
+- Branch comparison with auto-detection
+
 ## Support
 
 If you encounter any issues or have questions, please file an issue on the GitHub repository.
@@ -413,4 +642,4 @@ The generated tickets include:
 - Acceptance criteria
 - Story point estimate
 - Priority level
-- Reference to the original Errbit URL# Test change
+- Reference to the original Errbit URL

data/bin/n2b-test-jira

@@ -0,0 +1,273 @@
+#!/usr/bin/env ruby
+
+require 'net/http'
+require 'uri'
+require 'json'
+require 'base64'
+require 'yaml'
+
+# Jira API connection tester for N2B
+# Tests authentication, permissions, and specific ticket access
+class JiraConnectionTester
+  def initialize
+    @config_file = File.expand_path('~/.n2b/config.yml')
+    load_config
+  end
+
+  def load_config
+    unless File.exist?(@config_file)
+      puts "❌ Config file not found: #{@config_file}"
+      puts "Please run 'n2b --advanced-config' to set up Jira integration first."
+      exit 1
+    end
+
+    @config = YAML.load_file(@config_file)
+    @jira_config = @config['jira']
+
+    unless @jira_config && @jira_config['domain'] && @jira_config['email'] && @jira_config['api_key']
+      puts "❌ Jira configuration incomplete in #{@config_file}"
+      puts "Missing: domain, email, or api_key"
+      puts "Please run 'n2b --advanced-config' to configure Jira."
+      exit 1
+    end
+
+    # Handle domain that may or may not include protocol
+    domain = @jira_config['domain'].to_s.strip
+    if domain.start_with?('http://') || domain.start_with?('https://')
+      @base_url = "#{domain.chomp('/')}/rest/api/3"
+    else
+      @base_url = "https://#{domain.chomp('/')}/rest/api/3"
+    end
+
+    puts "✅ Config loaded successfully"
+    puts "   Domain: #{@jira_config['domain']}"
+    puts "   Email: #{@jira_config['email']}"
+    puts "   API Key: #{@jira_config['api_key'][0..10]}..." # Show only first part for security
+    puts "   Base URL: #{@base_url}"
+    puts
+  end
+
+  def test_connection
+    puts "🔍 Testing Jira API connection..."
+    puts "=" * 50
+
+    # Test 1: Basic API connectivity
+    test_basic_connectivity
+
+    # Test 2: Authentication
+    test_authentication
+
+    # Test 3: Permissions
+    test_permissions
+
+    # Test 4: Specific ticket access (if provided)
+    if ARGV[0]
+      test_ticket_access(ARGV[0])
+    else
+      puts "💡 To test specific ticket access, run: ruby test_jira_connection.rb TICKET-123"
+    end
+  end
+
+  private
+
+  def test_basic_connectivity
+    puts "1️⃣ Testing basic connectivity to Jira..."
+    
+    begin
+      uri = URI.parse(@base_url)
+      puts "   Connecting to: #{uri.host}:#{uri.port}"
+      
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = (uri.scheme == 'https')
+      http.open_timeout = 10
+      http.read_timeout = 10
+      
+      # Simple GET to the API root
+      request = Net::HTTP::Get.new('/rest/api/3/')
+      response = http.request(request)
+      
+      puts "   ✅ Connection successful (HTTP #{response.code})"
+      puts
+    rescue => e
+      puts "   ❌ Connection failed: #{e.message}"
+      puts "   Check your network connection and domain configuration."
+      exit 1
+    end
+  end
+
+  def test_authentication
+    puts "2️⃣ Testing authentication..."
+    
+    begin
+      response = make_api_request('GET', '/myself')
+      
+      if response['accountId']
+        puts "   ✅ Authentication successful"
+        puts "   Account ID: #{response['accountId']}"
+        puts "   Display Name: #{response['displayName']}"
+        puts "   Email: #{response['emailAddress']}"
+        puts
+      else
+        puts "   ⚠️  Authentication response unexpected:"
+        puts "   #{response}"
+        puts
+      end
+    rescue => e
+      puts "   ❌ Authentication failed: #{e.message}"
+      puts "   Check your email and API token."
+      puts "   API token should be generated from: https://id.atlassian.com/manage-profile/security/api-tokens"
+      exit 1
+    end
+  end
+
+  def test_permissions
+    puts "3️⃣ Testing required permissions..."
+
+    begin
+      # Test 1: Project access (Browse Projects permission)
+      response = make_api_request('GET', '/project')
+
+      if response.is_a?(Array) && response.length > 0
+        puts "   ✅ Browse Projects: Can access #{response.length} projects"
+        response.first(3).each do |project|
+          puts "     - #{project['key']}: #{project['name']}"
+        end
+        puts "     ... (showing first 3)" if response.length > 3
+
+        # Test 2: Issue access (Browse Issues permission)
+        test_project = response.first
+        puts "   🔍 Testing issue access in project: #{test_project['key']}"
+
+        begin
+          issues_response = make_api_request('GET', "/search?jql=project=#{test_project['key']}&maxResults=1")
+          if issues_response['issues'] && issues_response['issues'].length > 0
+            puts "   ✅ Browse Issues: Can access issues in #{test_project['key']}"
+
+            # Test 3: Comment access (if we found an issue)
+            test_issue = issues_response['issues'].first
+            begin
+              comments_response = make_api_request('GET', "/issue/#{test_issue['key']}/comment")
+              puts "   ✅ View Comments: Can access comments on #{test_issue['key']}"
+            rescue => e
+              puts "   ❌ View Comments: Cannot access comments (#{e.message})"
+            end
+
+            # Test 4: Add comment permission (we won't actually add, just check the endpoint)
+            puts "   ℹ️  Add Comments: Will be tested when actually posting comments"
+          else
+            puts "   ⚠️  No issues found in #{test_project['key']} to test comment permissions"
+          end
+        rescue => e
+          puts "   ❌ Browse Issues: Cannot search issues (#{e.message})"
+        end
+
+        puts
+      else
+        puts "   ❌ Browse Projects: No projects accessible"
+        puts "   Your API token needs 'Browse Projects' permission"
+        puts
+      end
+    rescue => e
+      puts "   ❌ Permission test failed: #{e.message}"
+      puts "   Your API token might not have sufficient permissions."
+      puts
+    end
+
+    puts "   📋 Required Jira Permissions for N2B:"
+    puts "   • Browse Projects - to access project list"
+    puts "   • Browse Issues - to read ticket details"
+    puts "   • View Comments - to read ticket comments"
+    puts "   • Add Comments - to post analysis results"
+    puts
+  end
+
+  def test_ticket_access(ticket_key)
+    puts "4️⃣ Testing access to specific ticket: #{ticket_key}..."
+    
+    begin
+      # Test ticket access
+      response = make_api_request('GET', "/issue/#{ticket_key}")
+      
+      puts "   ✅ Ticket access successful"
+      puts "   Key: #{response['key']}"
+      puts "   Summary: #{response.dig('fields', 'summary')}"
+      puts "   Status: #{response.dig('fields', 'status', 'name')}"
+      puts "   Assignee: #{response.dig('fields', 'assignee', 'displayName') || 'Unassigned'}"
+      puts
+      
+      # Test comments access
+      comments_response = make_api_request('GET', "/issue/#{ticket_key}/comment")
+      comment_count = comments_response.dig('comments')&.length || 0
+      puts "   ✅ Comments access successful (#{comment_count} comments)"
+      puts
+      
+    rescue => e
+      puts "   ❌ Ticket access failed: #{e.message}"
+      
+      if e.message.include?('404')
+        puts "   Possible causes:"
+        puts "   - Ticket doesn't exist"
+        puts "   - You don't have permission to view this ticket"
+        puts "   - Ticket is in a project you can't access"
+      elsif e.message.include?('401')
+        puts "   Authentication issue - check your API token"
+      elsif e.message.include?('403')
+        puts "   Permission denied - your account can't access this ticket"
+      end
+      puts
+    end
+  end
+
+  def make_api_request(method, path, body = nil)
+    full_url = "#{@base_url}#{path}"
+    uri = URI.parse(full_url)
+    
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = (uri.scheme == 'https')
+    http.read_timeout = 30
+    http.open_timeout = 10
+
+    request = case method.upcase
+              when 'GET'
+                Net::HTTP::Get.new(uri.request_uri)
+              when 'POST'
+                req = Net::HTTP::Post.new(uri.request_uri)
+                req.body = body.to_json if body
+                req
+              else
+                raise "Unsupported HTTP method: #{method}"
+              end
+
+    request['Authorization'] = "Basic #{Base64.strict_encode64("#{@jira_config['email']}:#{@jira_config['api_key']}")}"
+    request['Content-Type'] = 'application/json'
+    request['Accept'] = 'application/json'
+
+    response = http.request(request)
+
+    unless response.is_a?(Net::HTTPSuccess)
+      error_message = "Jira API Error: #{response.code} #{response.message}"
+      error_message += " - #{response.body}" if response.body && !response.body.empty?
+      raise error_message
+    end
+
+    response.body.empty? ? {} : JSON.parse(response.body)
+  rescue Timeout::Error, Errno::EINVAL, Errno::ECONNRESET, EOFError,
+         Net::HTTPBadResponse, Net::HTTPHeaderSyntaxError, Net::ProtocolError, Errno::ECONNREFUSED => e
+    raise "Jira API request failed: #{e.class} - #{e.message}"
+  end
+end
+
+# Run the test
+if __FILE__ == $0
+  puts "🧪 Jira API Connection Tester"
+  puts "=" * 50
+  puts
+
+  tester = JiraConnectionTester.new
+  tester.test_connection
+
+  puts "🎉 Test completed!"
+  puts
+  puts "If all tests passed, your Jira integration should work correctly."
+  puts "If any tests failed, check the error messages above for guidance."
+end