pluto-ai 1.0.0__py3-none-any.whl

pluto/__init__.py

@@ -0,0 +1,18 @@
+"""
+Pluto - AI-Powered Code Security Analyzer
+
+A powerful CLI tool that uses AI to detect security vulnerabilities in your code.
+
+Author: 0xSaikat
+Website: https://hackbit.org
+License: MIT
+"""
+
+__version__ = "1.0.0"
+__author__ = "0xSaikat"
+__email__ = "contact@hackbit.org"
+__license__ = "MIT"
+
+from pluto.cli import cli
+
+__all__ = ['cli']

pluto/analyzers/__init__.py

@@ -0,0 +1,11 @@
+"""
+Code analysis modules for Pluto.
+
+This package contains analyzers for different types of code inputs
+including single files, directories, and git repositories.
+"""
+
+from pluto.analyzers.code_analyzer import CodeAnalyzer
+from pluto.analyzers.git_analyzer import GitAnalyzer
+
+__all__ = ['CodeAnalyzer', 'GitAnalyzer']

pluto/analyzers/code_analyzer.py

@@ -0,0 +1,34 @@
+from typing import List, Dict, Optional
+import json
+
+class CodeAnalyzer:
+    def __init__(self, provider: str = 'claude', model: str = 'claude-sonnet-4-20250514'):
+        self.provider = provider
+        self.model = model
+        
+        if provider == 'claude':
+            from pluto.providers.claude_provider import ClaudeProvider
+            self.ai_provider = ClaudeProvider(model)
+        elif provider == 'openai':
+            from pluto.providers.openai_provider import OpenAIProvider
+            self.ai_provider = OpenAIProvider(model)
+        elif provider == 'ollama':
+            from pluto.providers.ollama_provider import OllamaProvider
+            self.ai_provider = OllamaProvider(model)
+        else:
+            raise ValueError(f"Unknown provider: {provider}")
+    
+    def analyze_file(self, file_path: str) -> List[Dict]:
+        """Analyze a single file for vulnerabilities"""
+        try:
+            with open(file_path, 'r', encoding='utf-8', errors='ignore') as f:
+                code = f.read()
+            
+            if not code.strip():
+                return []
+            
+            vulnerabilities = self.ai_provider.analyze_code(code, file_path)
+            return vulnerabilities
+        except Exception as e:
+            print(f"Error analyzing {file_path}: {str(e)}")
+            return []

pluto/analyzers/git_analyzer.py

@@ -0,0 +1,15 @@
+import os
+import tempfile
+import shutil
+from git import Repo
+
+class GitAnalyzer:
+    def clone_repo(self, repo_url: str) -> str:
+        """Clone a git repository to a temporary directory"""
+        temp_dir = tempfile.mkdtemp(prefix='pluto_')
+        try:
+            Repo.clone_from(repo_url, temp_dir, depth=1)
+            return temp_dir
+        except Exception as e:
+            shutil.rmtree(temp_dir, ignore_errors=True)
+            raise Exception(f"Failed to clone repository: {str(e)}")

pluto/cli.py

@@ -0,0 +1,131 @@
+import click
+import json
+import os
+from pathlib import Path
+from typing import Optional, List
+import sys
+
+def print_banner():
+    """Print the Pluto banner with styled text."""
+    banner = (
+        "\033[1;36m"  
+        "\n"
+        "╭─────[By 0xSaikat]───────────────────────────────────╮\n"
+        "│                                                     │\n"
+        "│         ____  __      __                            │\n"
+        "│        / __ \\/ /_  __/ /_____                       │\n"
+        "│       / /_/ / / / / / __/ __ \\                      │\n"
+        "│      / ____/ / /_/ / /_/ /_/ /                      │\n"
+        "│     /_/   /_/\\__,_/\\__/\\____/   V-1.0               │\n"
+        "│                                                     │\n"
+        "│     AI-Powered Code Security Analyzer               │\n"
+        "│                                                     │\n"
+        "╰─────────────────────────────────[hackbit.org]───────╯\n"
+        "\033[0m"  
+    )
+    print(banner)
+
+@click.group(invoke_without_command=True)
+@click.pass_context
+@click.version_option(version='1.0.0')
+def cli(ctx):
+    """Pluto - AI-Powered Code Security Analyzer"""
+    if ctx.invoked_subcommand is None:
+        print_banner()
+        click.echo("\nUse 'pluto scan --help' to see available options\n")
+
+@cli.command()
+@click.option('-code', '--code-file', type=click.Path(exists=True), help='Analyze a single code file')
+@click.option('-dir', '--directory', type=click.Path(exists=True), help='Analyze entire directory')
+@click.option('-git', '--git-repo', type=str, help='Analyze GitHub repository')
+@click.option('--provider', type=click.Choice(['claude', 'openai', 'ollama']), default='claude', help='AI provider')
+@click.option('--model', type=str, default='claude-sonnet-4-20250514', help='Model name')
+@click.option('--report', type=click.Choice(['terminal', 'pdf', 'json', 'html', 'markdown']), default='terminal', help='Report format')
+@click.option('--output', type=str, default='pluto_report', help='Output file name (without extension)')
+@click.option('--min-severity', type=click.Choice(['LOW', 'MEDIUM', 'HIGH', 'CRITICAL']), default='LOW', help='Minimum severity level')
+def scan(code_file, directory, git_repo, provider, model, report, output, min_severity):
+    """Scan code for security vulnerabilities"""
+    print_banner()  
+    from pluto.analyzers.code_analyzer import CodeAnalyzer
+    from pluto.reporters.terminal_reporter import TerminalReporter
+    from pluto.reporters.pdf_reporter import PDFReporter
+    from pluto.reporters.json_reporter import JSONReporter
+    from pluto.reporters.markdown_reporter import MarkdownReporter
+    
+    analyzer = CodeAnalyzer(provider=provider, model=model)
+    
+    
+    files_to_analyze = []
+    
+    if code_file:
+        files_to_analyze.append(code_file)
+    elif directory:
+        files_to_analyze = get_code_files(directory)
+    elif git_repo:
+        click.echo("Cloning repository...")
+        from pluto.analyzers.git_analyzer import GitAnalyzer
+        git_analyzer = GitAnalyzer()
+        repo_path = git_analyzer.clone_repo(git_repo)
+        files_to_analyze = get_code_files(repo_path)
+    else:
+        click.echo("Error: Please specify -code, -dir, or -git")
+        return
+    
+    if not files_to_analyze:
+        click.echo("No code files found to analyze")
+        return
+    
+    click.echo(f"Analyzing {len(files_to_analyze)} file(s)...")
+    
+    
+    all_results = []
+    for file_path in files_to_analyze:
+        click.echo(f"Scanning: {file_path}")
+        results = analyzer.analyze_file(file_path)
+        if results:
+            all_results.extend(results)
+    
+    
+    severity_order = {'LOW': 0, 'MEDIUM': 1, 'HIGH': 2, 'CRITICAL': 3}
+    min_level = severity_order[min_severity]
+    filtered_results = [r for r in all_results if severity_order.get(r.get('severity', 'LOW'), 0) >= min_level]
+    
+    if report == 'terminal' or report == 'terminal':
+        reporter = TerminalReporter()
+        reporter.generate(filtered_results)
+    
+    if report == 'pdf':
+        reporter = PDFReporter()
+        reporter.generate(filtered_results, f"{output}.pdf")
+        click.echo(f"\nPDF report saved to: {output}.pdf")
+    
+    if report == 'json':
+        reporter = JSONReporter()
+        reporter.generate(filtered_results, f"{output}.json")
+        click.echo(f"\nJSON report saved to: {output}.json")
+    
+    if report == 'markdown':
+        reporter = MarkdownReporter()
+        reporter.generate(filtered_results, f"{output}.md")
+        click.echo(f"\nMarkdown report saved to: {output}.md")
+
+def get_code_files(path):
+    """Get all code files from a directory"""
+    code_extensions = {'.py', '.js', '.jsx', '.ts', '.tsx', '.java', '.cpp', '.c', '.go', '.rs', '.php', '.rb', '.swift', '.kt'}
+    files = []
+    path_obj = Path(path)
+    
+    if path_obj.is_file():
+        return [str(path_obj)]
+    
+    for file in path_obj.rglob('*'):
+        if file.is_file() and file.suffix in code_extensions:
+            
+            if any(skip in file.parts for skip in ['node_modules', 'venv', '.git', '__pycache__', 'dist', 'build']):
+                continue
+            files.append(str(file))
+    
+    return files
+
+if __name__ == '__main__':
+    cli()

pluto/providers/__init__.py

@@ -0,0 +1,12 @@
+"""
+AI provider integrations for Pluto.
+
+This package contains integrations with various AI providers
+including Claude (Anthropic), OpenAI, and Ollama (local).
+"""
+
+from pluto.providers.claude_provider import ClaudeProvider
+from pluto.providers.openai_provider import OpenAIProvider
+from pluto.providers.ollama_provider import OllamaProvider
+
+__all__ = ['ClaudeProvider', 'OpenAIProvider', 'OllamaProvider']

pluto/providers/claude_provider.py

@@ -0,0 +1,110 @@
+import os
+import json
+from typing import List, Dict
+
+class ClaudeProvider:
+    def __init__(self, model: str = 'claude-sonnet-4-20250514'):
+        self.model = model
+        try:
+            from anthropic import Anthropic
+            api_key = os.environ.get('ANTHROPIC_API_KEY')
+            if not api_key:
+                raise ValueError("ANTHROPIC_API_KEY environment variable not set")
+            self.client = Anthropic(api_key=api_key)
+        except ImportError:
+            raise ImportError("Please install: pip install anthropic")
+    
+    def analyze_code(self, code: str, file_path: str) -> List[Dict]:
+        """Analyze code using Claude"""
+        prompt = self._create_prompt(code, file_path)
+        
+        try:
+            response = self.client.messages.create(
+                model=self.model,
+                max_tokens=4096,
+                messages=[
+                    {"role": "user", "content": prompt}
+                ]
+            )
+            
+            result_text = response.content[0].text
+            
+            vulnerabilities = self._parse_response(result_text)
+            return vulnerabilities
+        except Exception as e:
+            print(f"Error calling Claude API: {str(e)}")
+            return []
+    
+    def _create_prompt(self, code: str, file_path: str) -> str:
+        return f"""Analyze the following code for security vulnerabilities. Focus on:
+
+1. SQL Injection
+2. XSS (Cross-Site Scripting)
+3. Authentication/Authorization issues
+4. Hardcoded secrets/credentials
+5. Insecure cryptography
+6. Path traversal
+7. Command injection
+8. CSRF vulnerabilities
+9. Insecure dependencies
+10. Buffer overflows
+11. Race conditions
+12. Logic flaws
+
+File: {file_path}
+
+Code:
+```
+{code}
+```
+
+For each vulnerability found, provide a JSON object with:
+- severity: "CRITICAL", "HIGH", "MEDIUM", or "LOW"
+- type: vulnerability type
+- line: approximate line number (if identifiable)
+- description: what's vulnerable
+- impact: potential damage
+- recommendation: how to fix
+
+Return ONLY a JSON array of vulnerabilities. If no vulnerabilities found, return an empty array [].
+Do not include any explanation, just the JSON array."""
+    
+    def _parse_response(self, response: str) -> List[Dict]:
+        """Parse AI response to extract vulnerabilities"""
+        try:
+            
+            start = response.find('[')
+            end = response.rfind(']') + 1
+            
+            if start != -1 and end > start:
+                json_str = response[start:end]
+                vulnerabilities = json.loads(json_str)
+                
+                
+                for vuln in vulnerabilities:
+                    severity = vuln.get('severity', 'LOW')
+
+                    if '|' in severity:
+                        levels = severity.split('|')
+                        if 'CRITICAL' in levels:
+                            vuln['severity'] = 'CRITICAL'
+                        elif 'HIGH' in levels:
+                            vuln['severity'] = 'HIGH'
+                        elif 'MEDIUM' in levels:
+                            vuln['severity'] = 'MEDIUM'
+                        else:
+                            vuln['severity'] = 'LOW'
+                    else:
+                        
+                        severity = severity.upper().strip()
+                        if severity not in ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW']:
+                            vuln['severity'] = 'MEDIUM' 
+                        else:
+                            vuln['severity'] = severity
+                
+                return vulnerabilities
+            
+            return []
+        except json.JSONDecodeError:
+            print("Failed to parse JSON response")
+            return []

pluto/providers/ollama_provider.py

@@ -0,0 +1,90 @@
+import json
+from typing import List, Dict
+import requests
+
+class OllamaProvider:
+    def __init__(self, model: str = 'codellama'):
+        self.model = model
+        self.base_url = "http://localhost:11434"
+    
+    def analyze_code(self, code: str, file_path: str) -> List[Dict]:
+        """Analyze code using Ollama"""
+        prompt = self._create_prompt(code, file_path)
+        
+        try:
+            response = requests.post(
+                f"{self.base_url}/api/generate",
+                json={
+                    "model": self.model,
+                    "prompt": prompt,
+                    "stream": False
+                },
+                timeout=120
+            )
+            
+            if response.status_code == 200:
+                result = response.json()
+                result_text = result.get('response', '')
+                return self._parse_response(result_text)
+            else:
+                print(f"Ollama API error: {response.status_code}")
+                return []
+        except requests.exceptions.ConnectionError:
+            print("Error: Cannot connect to Ollama. Make sure Ollama is running (ollama serve)")
+            return []
+        except Exception as e:
+            print(f"Error calling Ollama: {str(e)}")
+            return []
+    
+    def _create_prompt(self, code: str, file_path: str) -> str:
+        return f"""Analyze this code for security vulnerabilities.
+
+File: {file_path}
+
+Code:
+```
+{code}
+```
+
+Find security issues like: SQL injection, XSS, hardcoded secrets, insecure crypto, command injection, etc.
+
+Return ONLY a JSON array. Format:
+[{{"severity": "CRITICAL|HIGH|MEDIUM|LOW", "type": "issue type", "line": number, "description": "what's wrong", "impact": "potential damage", "recommendation": "how to fix"}}]
+
+If no issues, return []. JSON only, no explanation."""
+    
+    def _parse_response(self, response: str) -> List[Dict]:
+        """Parse Ollama response"""
+        try:
+            start = response.find('[')
+            end = response.rfind(']') + 1
+            
+            if start != -1 and end > start:
+                json_str = response[start:end]
+                vulnerabilities = json.loads(json_str)
+                
+                for vuln in vulnerabilities:
+                    severity = vuln.get('severity', 'LOW')
+
+                    if '|' in severity:
+                        levels = severity.split('|')
+                        if 'CRITICAL' in levels:
+                            vuln['severity'] = 'CRITICAL'
+                        elif 'HIGH' in levels:
+                            vuln['severity'] = 'HIGH'
+                        elif 'MEDIUM' in levels:
+                            vuln['severity'] = 'MEDIUM'
+                        else:
+                            vuln['severity'] = 'LOW'
+                    else:
+                        
+                        severity = severity.upper().strip()
+                        if severity not in ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW']:
+                            vuln['severity'] = 'MEDIUM'
+                        else:
+                            vuln['severity'] = severity
+                
+                return vulnerabilities
+            return []
+        except json.JSONDecodeError:
+            return []

pluto/providers/openai_provider.py

@@ -0,0 +1,95 @@
+import os
+import json
+from typing import List, Dict
+
+class OpenAIProvider:
+    def __init__(self, model: str = 'gpt-4'):
+        self.model = model
+        try:
+            from openai import OpenAI
+            api_key = os.environ.get('OPENAI_API_KEY')
+            if not api_key:
+                raise ValueError("OPENAI_API_KEY environment variable not set")
+            self.client = OpenAI(api_key=api_key)
+        except ImportError:
+            raise ImportError("Please install: pip install openai")
+    
+    def analyze_code(self, code: str, file_path: str) -> List[Dict]:
+        """Analyze code using OpenAI"""
+        prompt = self._create_prompt(code, file_path)
+        
+        try:
+            response = self.client.chat.completions.create(
+                model=self.model,
+                messages=[
+                    {"role": "system", "content": "You are a security expert analyzing code for vulnerabilities."},
+                    {"role": "user", "content": prompt}
+                ],
+                temperature=0.3
+            )
+            
+            result_text = response.choices[0].message.content
+            vulnerabilities = self._parse_response(result_text)
+            return vulnerabilities
+        except Exception as e:
+            print(f"Error calling OpenAI API: {str(e)}")
+            return []
+    
+    def _create_prompt(self, code: str, file_path: str) -> str:
+        return f"""Analyze the following code for security vulnerabilities.
+
+File: {file_path}
+
+Code:
+```
+{code}
+```
+
+Return ONLY a JSON array of vulnerabilities. Format:
+[
+  {{
+    "severity": "CRITICAL|HIGH|MEDIUM|LOW",
+    "type": "vulnerability type",
+    "line": line_number,
+    "description": "description",
+    "impact": "impact",
+    "recommendation": "fix"
+  }}
+]
+
+If no vulnerabilities, return []."""
+    
+    def _parse_response(self, response: str) -> List[Dict]:
+        """Parse AI response to extract vulnerabilities"""
+        try:
+            start = response.find('[')
+            end = response.rfind(']') + 1
+            
+            if start != -1 and end > start:
+                json_str = response[start:end]
+                vulnerabilities = json.loads(json_str)
+                
+                for vuln in vulnerabilities:
+                    severity = vuln.get('severity', 'LOW')
+                    
+                    if '|' in severity:
+                        levels = severity.split('|')
+                        if 'CRITICAL' in levels:
+                            vuln['severity'] = 'CRITICAL'
+                        elif 'HIGH' in levels:
+                            vuln['severity'] = 'HIGH'
+                        elif 'MEDIUM' in levels:
+                            vuln['severity'] = 'MEDIUM'
+                        else:
+                            vuln['severity'] = 'LOW'
+                    else:
+                        severity = severity.upper().strip()
+                        if severity not in ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW']:
+                            vuln['severity'] = 'MEDIUM'
+                        else:
+                            vuln['severity'] = severity
+                
+                return vulnerabilities
+            return []
+        except json.JSONDecodeError:
+            return []

pluto/reporters/__init__.py

@@ -0,0 +1,18 @@
+"""
+Report generation modules for Pluto.
+
+This package contains different report formats including
+terminal, PDF, JSON, and Markdown outputs.
+"""
+
+from pluto.reporters.terminal_reporter import TerminalReporter
+from pluto.reporters.pdf_reporter import PDFReporter
+from pluto.reporters.json_reporter import JSONReporter
+from pluto.reporters.markdown_reporter import MarkdownReporter
+
+__all__ = [
+    'TerminalReporter',
+    'PDFReporter',
+    'JSONReporter',
+    'MarkdownReporter'
+]

pluto/reporters/json_reporter.py

@@ -0,0 +1,21 @@
+import json
+from typing import List, Dict
+
+class JSONReporter:
+    def generate(self, vulnerabilities: List[Dict], output_file: str):
+        """Generate JSON report"""
+        report = {
+            "total_vulnerabilities": len(vulnerabilities),
+            "severity_summary": self._get_severity_summary(vulnerabilities),
+            "vulnerabilities": vulnerabilities
+        }
+        
+        with open(output_file, 'w') as f:
+            json.dump(report, f, indent=2)
+    
+    def _get_severity_summary(self, vulnerabilities: List[Dict]) -> Dict:
+        summary = {'CRITICAL': 0, 'HIGH': 0, 'MEDIUM': 0, 'LOW': 0}
+        for vuln in vulnerabilities:
+            severity = vuln.get('severity', 'LOW')
+            summary[severity] = summary.get(severity, 0) + 1
+        return summary

pluto/reporters/markdown_reporter.py

@@ -0,0 +1,34 @@
+from typing import List, Dict
+from datetime import datetime
+
+class MarkdownReporter:
+    def generate(self, vulnerabilities: List[Dict], output_file: str):
+        """Generate Markdown report"""
+        lines = []
+        lines.append("# Pluto Security Scan Report\n")
+        lines.append(f"**Generated:** {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}\n")
+        lines.append(f"**Total Vulnerabilities:** {len(vulnerabilities)}\n")
+        
+        severity_count = {'CRITICAL': 0, 'HIGH': 0, 'MEDIUM': 0, 'LOW': 0}
+        for vuln in vulnerabilities:
+            severity = vuln.get('severity', 'LOW')
+            severity_count[severity] = severity_count.get(severity, 0) + 1
+        
+        lines.append("\n## Severity Summary\n")
+        lines.append("| Severity | Count |\n")
+        lines.append("|----------|-------|\n")
+        for severity, count in severity_count.items():
+            lines.append(f"| {severity} | {count} |\n")
+        
+        lines.append("\n## Detailed Findings\n")
+        for i, vuln in enumerate(vulnerabilities, 1):
+            lines.append(f"\n### [{i}] {vuln.get('severity', 'LOW')} - {vuln.get('type', 'Unknown')}\n")
+            lines.append(f"**Description:** {vuln.get('description', 'N/A')}\n\n")
+            lines.append(f"**Impact:** {vuln.get('impact', 'N/A')}\n\n")
+            lines.append(f"**Recommendation:** {vuln.get('recommendation', 'N/A')}\n")
+            if vuln.get('line'):
+                lines.append(f"**Line:** {vuln['line']}\n")
+            lines.append("\n---\n")
+        
+        with open(output_file, 'w') as f:
+            f.writelines(lines)

pluto/reporters/pdf_reporter.py

@@ -0,0 +1,140 @@
+from typing import List, Dict
+from datetime import datetime
+import os
+
+class PDFReporter:
+    def generate(self, vulnerabilities: List[Dict], output_file: str):
+        """Generate PDF report with logo"""
+        try:
+            from reportlab.lib.pagesizes import letter
+            from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+            from reportlab.lib.units import inch
+            from reportlab.platypus import SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, Image
+            from reportlab.lib import colors
+            from reportlab.lib.enums import TA_CENTER
+        except ImportError:
+            print("Error: reportlab not installed. Install with: pip install reportlab")
+            return
+        
+        doc = SimpleDocTemplate(output_file, pagesize=letter)
+        styles = getSampleStyleSheet()
+        story = []
+        
+        logo_path = os.path.join(os.path.dirname(__file__), '..', 'assets', 'logo.png')
+        if os.path.exists(logo_path):
+            try:
+                logo = Image(logo_path, width=2*inch, height=2*inch)
+                logo.hAlign = 'CENTER'
+                story.append(logo)
+                story.append(Spacer(1, 0.3*inch))
+            except:
+                pass
+        
+        title_style = ParagraphStyle(
+            'CustomTitle',
+            parent=styles['Heading1'],
+            fontSize=28,
+            textColor=colors.HexColor('#00CED1'),
+            spaceAfter=10,
+            alignment=TA_CENTER,
+            fontName='Helvetica-Bold'
+        )
+        story.append(Paragraph("🛡️ PLUTO SECURITY REPORT 🛡️", title_style))
+        
+        subtitle_style = ParagraphStyle(
+            'Subtitle',
+            parent=styles['Normal'],
+            fontSize=12,
+            textColor=colors.HexColor('#666666'),
+            alignment=TA_CENTER,
+            spaceAfter=20,
+        )
+        story.append(Paragraph("AI-Powered Code Security Analyzer", subtitle_style))
+        story.append(Paragraph("by 0xSaikat | hackbit.org", subtitle_style))
+        story.append(Spacer(1, 0.3*inch))
+        
+        story.append(Paragraph(f"<b>Generated:</b> {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}", styles['Normal']))
+        story.append(Paragraph(f"<b>Total Vulnerabilities Found:</b> {len(vulnerabilities)}", styles['Normal']))
+        story.append(Spacer(1, 0.3*inch))
+        
+        severity_count = {'CRITICAL': 0, 'HIGH': 0, 'MEDIUM': 0, 'LOW': 0}
+        for vuln in vulnerabilities:
+            severity = vuln.get('severity', 'LOW')
+            severity_count[severity] = severity_count.get(severity, 0) + 1
+        
+        data = [['Severity Level', 'Count', 'Priority']]
+        for severity in ['CRITICAL', 'HIGH', 'MEDIUM', 'LOW']:
+            count = severity_count[severity]
+            priority = '🔴' if severity == 'CRITICAL' else '🟠' if severity == 'HIGH' else '🟡' if severity == 'MEDIUM' else '🟢'
+            data.append([severity, str(count), priority])
+        
+        table = Table(data, colWidths=[2*inch, 1.5*inch, 1.5*inch])
+        table.setStyle(TableStyle([
+            ('BACKGROUND', (0, 0), (-1, 0), colors.HexColor('#00CED1')),
+            ('TEXTCOLOR', (0, 0), (-1, 0), colors.whitesmoke),
+            ('ALIGN', (0, 0), (-1, -1), 'CENTER'),
+            ('FONTNAME', (0, 0), (-1, 0), 'Helvetica-Bold'),
+            ('FONTSIZE', (0, 0), (-1, 0), 14),
+            ('BOTTOMPADDING', (0, 0), (-1, 0), 12),
+            ('BACKGROUND', (0, 1), (-1, -1), colors.beige),
+            ('GRID', (0, 0), (-1, -1), 1, colors.black),
+            ('ROWBACKGROUNDS', (0, 1), (-1, -1), [colors.white, colors.lightgrey])
+        ]))
+        story.append(table)
+        story.append(Spacer(1, 0.5*inch))
+        
+        vuln_header_style = ParagraphStyle(
+            'VulnHeader',
+            parent=styles['Heading2'],
+            fontSize=18,
+            textColor=colors.HexColor('#00CED1'),
+            spaceAfter=20,
+        )
+        story.append(Paragraph("📋 Detailed Vulnerability Findings", vuln_header_style))
+        story.append(Spacer(1, 0.2*inch))
+        
+        if not vulnerabilities:
+            story.append(Paragraph("✅ <b>No vulnerabilities detected!</b>", styles['Normal']))
+        else:
+            severity_colors = {
+                'CRITICAL': colors.HexColor('#FF0000'),
+                'HIGH': colors.HexColor('#FF6600'),
+                'MEDIUM': colors.HexColor('#FFA500'),
+                'LOW': colors.HexColor('#00AA00')
+            }
+            
+            for i, vuln in enumerate(vulnerabilities, 1):
+                severity = vuln.get('severity', 'LOW')
+                severity_color = severity_colors.get(severity, colors.black)
+                
+                vuln_title_style = ParagraphStyle(
+                    'VulnTitle',
+                    parent=styles['Heading3'],
+                    fontSize=14,
+                    textColor=severity_color,
+                    spaceAfter=10,
+                )
+                
+                story.append(Paragraph(f"<b>[{i}] {severity} - {vuln.get('type', 'Unknown')}</b>", vuln_title_style))
+                
+                if vuln.get('line'):
+                    story.append(Paragraph(f"<b>📍 Location:</b> Line {vuln['line']}", styles['Normal']))
+                
+                story.append(Paragraph(f"<b>📝 Description:</b> {vuln.get('description', 'N/A')}", styles['Normal']))
+                story.append(Paragraph(f"<b>💥 Impact:</b> {vuln.get('impact', 'N/A')}", styles['Normal']))
+                story.append(Paragraph(f"<b>✅ Recommendation:</b> {vuln.get('recommendation', 'N/A')}", styles['Normal']))
+                story.append(Spacer(1, 0.3*inch))
+        
+        story.append(Spacer(1, 0.5*inch))
+        footer_style = ParagraphStyle(
+            'Footer',
+            parent=styles['Normal'],
+            fontSize=10,
+            textColor=colors.HexColor('#666666'),
+            alignment=TA_CENTER,
+        )
+        story.append(Paragraph("─" * 80, footer_style))
+        story.append(Paragraph("Generated by Pluto v1.0 | hackbit.org", footer_style))
+        story.append(Paragraph("AI-Powered Security Analysis Tool", footer_style))
+        
+        doc.build(story)

pluto/reporters/terminal_reporter.py

@@ -0,0 +1,47 @@
+from typing import List, Dict
+
+class TerminalReporter:
+    COLORS = {
+        'CRITICAL': '\033[91m',  
+        'HIGH': '\033[93m',      
+        'MEDIUM': '\033[94m',    
+        'LOW': '\033[92m',       
+        'RESET': '\033[0m',
+        'BOLD': '\033[1m'
+    }
+    
+    def generate(self, vulnerabilities: List[Dict]):
+        """Generate terminal report"""
+        if not vulnerabilities:
+            print(f"\n{self.COLORS['BOLD']}✓ No vulnerabilities found!{self.COLORS['RESET']}\n")
+            return
+        
+        print(f"\n{self.COLORS['BOLD']}{'='*80}{self.COLORS['RESET']}")
+        print(f"{self.COLORS['BOLD']}PLUTO SECURITY SCAN REPORT{self.COLORS['RESET']}")
+        print(f"{self.COLORS['BOLD']}{'='*80}{self.COLORS['RESET']}\n")
+        
+        severity_count = {'CRITICAL': 0, 'HIGH': 0, 'MEDIUM': 0, 'LOW': 0}
+        for vuln in vulnerabilities:
+            severity = vuln.get('severity', 'LOW')
+            severity_count[severity] = severity_count.get(severity, 0) + 1
+        
+        print(f"Total Issues: {len(vulnerabilities)}")
+        print(f"  {self.COLORS['CRITICAL']}● CRITICAL: {severity_count['CRITICAL']}{self.COLORS['RESET']}")
+        print(f"  {self.COLORS['HIGH']}● HIGH: {severity_count['HIGH']}{self.COLORS['RESET']}")
+        print(f"  {self.COLORS['MEDIUM']}● MEDIUM: {severity_count['MEDIUM']}{self.COLORS['RESET']}")
+        print(f"  {self.COLORS['LOW']}● LOW: {severity_count['LOW']}{self.COLORS['RESET']}\n")
+        
+        for i, vuln in enumerate(vulnerabilities, 1):
+            severity = vuln.get('severity', 'LOW')
+            color = self.COLORS.get(severity, self.COLORS['RESET'])
+            
+            print(f"{color}{self.COLORS['BOLD']}[{i}] {severity}{self.COLORS['RESET']}")
+            print(f"Type: {vuln.get('type', 'Unknown')}")
+            
+            if vuln.get('line'):
+                print(f"Line: {vuln['line']}")
+            
+            print(f"Description: {vuln.get('description', 'N/A')}")
+            print(f"Impact: {vuln.get('impact', 'N/A')}")
+            print(f"Recommendation: {vuln.get('recommendation', 'N/A')}")
+            print(f"{'-'*80}\n")

pluto/utils/__init__.py

@@ -0,0 +1,5 @@
+"""
+Utility functions for Pluto.
+"""
+
+__all__ = []

pluto_ai-1.0.0.dist-info/METADATA

@@ -0,0 +1,241 @@
+Metadata-Version: 2.4
+Name: pluto-ai
+Version: 1.0.0
+Summary: AI-powered code security vulnerability scanner
+Home-page: https://github.com/0xsaikat/pluto
+Author: 0xSaikat
+Author-email: 0xSaikat <contact@hackbit.org>
+License: MIT
+Project-URL: Homepage, https://hackbit.org
+Project-URL: Repository, https://github.com/0xsaikat/pluto
+Project-URL: Issues, https://github.com/0xsaikat/pluto/issues
+Keywords: security,vulnerability,scanner,code-analysis,ai,static-analysis
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Security
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+Requires-Dist: click>=8.0.0
+Requires-Dist: anthropic>=0.18.0
+Requires-Dist: openai>=1.0.0
+Requires-Dist: requests>=2.28.0
+Requires-Dist: GitPython>=3.1.0
+Requires-Dist: reportlab>=4.0.0
+Dynamic: author
+Dynamic: home-page
+Dynamic: requires-python
+
+# 🛡️ Pluto - AI-Powered Code Security Analyzer
+
+<div align="center">
+
+```
+╭─────[By 0xSaikat]───────────────────────────────────╮
+│                                                     │
+│         ____  __      __                            │
+│        / __ \/ /_  __/ /_____                       │
+│       / /_/ / / / / / __/ __ \                      │
+│      / ____/ / /_/ / /_/ /_/ /                      │
+│     /_/   /_/\__,_/\__/\____/   V-1.0               │
+│                                                     │
+│     AI-Powered Code Security Analyzer               │
+│                                                     │
+╰─────────────────────────────────[hackbit.org]───────╯
+```
+
+[![PyPI version](https://badge.fury.io/py/pluto-security-scanner.svg)](https://badge.fury.io/py/pluto-security-scanner)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![Python 3.7+](https://img.shields.io/badge/python-3.7+-blue.svg)](https://www.python.org/downloads/)
+
+**Pluto** is a powerful CLI tool that uses AI to detect security vulnerabilities in your code.
+
+[Features](#-features) • [Installation](#-installation) • [Usage](#-usage) • [Examples](#-examples) • [Contributing](#-contributing)
+
+</div>
+
+---
+
+## 🚀 Features
+
+- 🤖 **Multiple AI Providers**: Claude, OpenAI, Ollama (local)
+- 📁 **Flexible Input**: Analyze files, directories, or GitHub repositories
+- 📊 **Multiple Report Formats**: Terminal, PDF, JSON, Markdown
+- 🔒 **Privacy-First**: Local analysis with Ollama support
+- 🎯 **Severity Filtering**: Focus on CRITICAL, HIGH, MEDIUM, or LOW issues
+- 🌐 **Multi-Language Support**: Python, JavaScript, Java, C/C++, Go, Rust, PHP, Ruby, and more
+
+## 🔍 Security Checks
+
+Pluto detects:
+- SQL Injection
+- XSS (Cross-Site Scripting)
+- Authentication/Authorization flaws
+- Hardcoded secrets & credentials
+- Insecure cryptography
+- Path traversal
+- Command injection
+- CSRF vulnerabilities
+- Insecure dependencies
+- And many more...
+
+## 📦 Installation
+
+### From PyPI (Recommended)
+```bash
+pip install pluto-ai
+```
+
+### From Source
+```bash
+git clone https://github.com/0xsaikat/pluto.git
+cd pluto
+pip install -e .
+```
+
+## ⚙️ Setup
+
+### For Claude (Recommended)
+```bash
+export ANTHROPIC_API_KEY='your-api-key-here'
+```
+Get your API key from: https://console.anthropic.com/
+
+### For OpenAI
+```bash
+export OPENAI_API_KEY='your-api-key-here'
+```
+
+### For Ollama (Local, Free)
+```bash
+# Install Ollama from https://ollama.ai
+ollama pull phi
+ollama serve
+```
+
+## 💻 Usage
+
+### Basic Commands
+
+```bash
+# Analyze a single file
+pluto scan -code app.py
+
+# Analyze entire directory
+pluto scan -dir ./src --report pdf --output security_report
+
+# Analyze GitHub repository
+pluto scan -git https://github.com/user/repo --provider claude
+
+# Use local AI (Ollama)
+pluto scan -code app.py --provider ollama --model phi
+
+# Filter by severity
+pluto scan -dir ./src --min-severity HIGH
+```
+
+### Command Options
+
+```
+Options:
+  -code, --code-file PATH         Analyze a single code file
+  -dir, --directory PATH          Analyze entire directory
+  -git, --git-repo TEXT           Analyze GitHub repository
+  --provider [claude|openai|ollama]  AI provider (default: claude)
+  --model TEXT                    Model name
+  --report [terminal|pdf|json|markdown]  Report format (default: terminal)
+  --output TEXT                   Output file name
+  --min-severity [LOW|MEDIUM|HIGH|CRITICAL]  Minimum severity level
+  --help                          Show this message and exit
+```
+
+## 📚 Examples
+
+### Quick Security Scan
+```bash
+pluto scan -code myapp.py
+```
+
+### Full Project Audit
+```bash
+pluto scan -dir ./backend --provider claude --report pdf --output project_audit
+```
+
+### GitHub Repository Analysis
+```bash
+pluto scan -git https://github.com/user/vulnerable-app --report json
+```
+
+### Local Private Scan
+```bash
+pluto scan -code sensitive_code.py --provider ollama --model phi
+```
+
+### CI/CD Integration
+```bash
+pluto scan -dir ./src --report json --output results.json --min-severity HIGH
+```
+
+## 📊 Report Formats
+
+- **Terminal**: Colorful, real-time output with severity highlighting
+- **PDF**: Professional report with logo, charts, and detailed findings
+- **JSON**: Machine-readable format for automation and CI/CD
+- **Markdown**: Documentation-friendly format
+
+## 🎨 Supported Languages
+
+Python • JavaScript • TypeScript • Java • C/C++ • Go • Rust • PHP • Ruby • Swift • Kotlin
+
+## 🔧 Configuration
+
+Create a `.plutorc` file in your project root:
+
+```yaml
+provider: claude
+model: claude-sonnet-4-20250514
+min_severity: MEDIUM
+report_format: pdf
+output_dir: ./security-reports
+```
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/AmazingFeature`)
+3. Commit your changes (`git commit -m 'Add some AmazingFeature'`)
+4. Push to the branch (`git push origin feature/AmazingFeature`)
+5. Open a Pull Request
+
+## 📝 License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.
+
+## 👨‍💻 Author
+
+**0xSaikat**
+- Website: [hackbit.org](https://hackbit.org)
+- GitHub: [@0xsaikat](https://github.com/0xsaikat)
+
+## 🙏 Acknowledgments
+
+- Powered by Claude (Anthropic), OpenAI, and Ollama
+- Built with ❤️ for the security community
+
+## ⚠️ Disclaimer
+
+Pluto is a security analysis tool intended for educational and legitimate security testing purposes only. Always ensure you have permission before scanning code or repositories you don't own.
+
+---
+
+<div align="center">
+Made with 🛡️ by 0xSaikat | <a href="https://hackbit.org">hackbit.org</a>
+</div>

pluto_ai-1.0.0.dist-info/RECORD

@@ -0,0 +1,34 @@
+pluto/__init__.py,sha256=TTmJeJ0nFpVYXyf6zkCACzeO28mscePECmQ84e8TBh0,339
+pluto/cli.py,sha256=PCCfo_nxkbc6vEj_KHKHcfM0q3xIlKVOBNIVRWLppxI,5483
+pluto/__pycache__/__init__.cpython-313.pyc,sha256=0tAqBWYvu5Bb_m-W75EJUlGYb0HrDYsS-S5iLp300Xg,549
+pluto/__pycache__/cli.cpython-313.pyc,sha256=u9M-ZRLsHNqWWVuHCySrZSxKucA9kK2n8CAwGlvDbKc,7389
+pluto/analyzers/__init__.py,sha256=pmycDq41M7GTCu4dZakpHWQ1fZyGs5wyuGsHOGmFzB4,319
+pluto/analyzers/code_analyzer.py,sha256=jGD5DxOQH8q6mJPAsGL745ernyHptVihStBWqwudghw,1336
+pluto/analyzers/git_analyzer.py,sha256=v-PfTC1tXyKzI_ZAi4AsaMOZWel-U_BefhyQIXsvd_U,497
+pluto/analyzers/__pycache__/__init__.cpython-313.pyc,sha256=weev9qMQwN2igv0qNQxgWMdEr4aWQNrv-kASGdalObk,516
+pluto/analyzers/__pycache__/code_analyzer.cpython-313.pyc,sha256=2sxPOFfMX7Mbz4_Wm95v5z-uI7VTqn5G_nJWR0FVP5A,2202
+pluto/analyzers/__pycache__/git_analyzer.cpython-313.pyc,sha256=46TH3OpjeuvCFtdlGY6jh4xOFuUcIs6zthx4b6mr6MQ,1199
+pluto/providers/__init__.py,sha256=69FM9e28yG9WY2L1_nlL3_ZUcObaSqMqm_NaeR4oSZI,407
+pluto/providers/claude_provider.py,sha256=1JN62lcJ5ZNpbczK4dihAvJTlHlaMsCEVJ3FmHOEvVs,3729
+pluto/providers/ollama_provider.py,sha256=8-7s1OZ41HbOYViROqBlULPXEOMq0lrjmfW-HbeA2Zs,3271
+pluto/providers/openai_provider.py,sha256=2MtqF47W7EctCsnDu8ZUpbXLj0geMLau9nUW52M9i7c,3276
+pluto/providers/__pycache__/__init__.cpython-313.pyc,sha256=f385h9iX_ISfx658L2toU2vo6jVDXTnwmOHkxBaWXQI,595
+pluto/providers/__pycache__/claude_provider.cpython-313.pyc,sha256=IMGMh-V0jOmA7g_ZBH-QnRgZxBGbFB3NUmlsjtRqAqA,4531
+pluto/providers/__pycache__/ollama_provider.cpython-313.pyc,sha256=4v0BEYGEHIY1qn4tyFOq-9X3uJh0dJ3AEPedVpmqAw8,4022
+pluto/providers/__pycache__/openai_provider.cpython-313.pyc,sha256=_ks1GUR6AVNzN1uCz5gkNLW92ZfQH8bBR2z3324pEiU,4155
+pluto/reporters/__init__.py,sha256=6Dfa9zmPtxIPZ1NTnXeJHUrS7Jt_A3DcDZpEwTQETLU,482
+pluto/reporters/json_reporter.py,sha256=dbFiKHAnsLqa6Q5fssBdtCHijlpkqI7ggbZFB68LfzE,794
+pluto/reporters/markdown_reporter.py,sha256=yjCQMuUYN_z0ZEndBGSETOyxlG41UsxvsydRYruR-Ks,1616
+pluto/reporters/pdf_reporter.py,sha256=y3fYRxLsTzWJ2yLZtl_m2JMqKdq9q3J3hoVkravLzW8,6247
+pluto/reporters/terminal_reporter.py,sha256=YX-ns_2-jWgnLiX4PHTBsltNKYC9NB7a9uJy-QQX0xc,2154
+pluto/reporters/__pycache__/__init__.cpython-313.pyc,sha256=GG8hvKPhcBC1CRhuJBJXEKc9296KRp3gjEAy5I6NGqc,653
+pluto/reporters/__pycache__/json_reporter.cpython-313.pyc,sha256=vl0K8BDFDx5oc4Ua61wUgLuqa9dS1jhmtTB_tw20OQA,1537
+pluto/reporters/__pycache__/markdown_reporter.cpython-313.pyc,sha256=X0kBZNxyoyh-EVfOhrlYEW8pz5OzsabvBTFCEKyf8VI,3002
+pluto/reporters/__pycache__/pdf_reporter.cpython-313.pyc,sha256=hM0jhelWsqIRMZSc-f2g5Xtbj9b6uGhEqwpujZW0JAw,7906
+pluto/reporters/__pycache__/terminal_reporter.cpython-313.pyc,sha256=wug8LzBnIfu1c7gtAEZwyFvdrbRYBEEnP1nyhtXbmis,3669
+pluto/utils/__init__.py,sha256=5WlXW0QLNc2t2UyqFBHOkAfNh4lUrJmAK7GbzDqjhow,50
+pluto_ai-1.0.0.dist-info/METADATA,sha256=TBu4UneeiVOR6bVxkzSH5yboZbEA_rpkYMWeP1iIl2s,7195
+pluto_ai-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pluto_ai-1.0.0.dist-info/entry_points.txt,sha256=ridTJ852BSoC8KA1DVhgyn0mYFMniNINKwr5am5INLM,40
+pluto_ai-1.0.0.dist-info/top_level.txt,sha256=KsGEOpwgREN1s1vqrZwUQCHhyc3oJ18-ldioP1XCjdA,6
+pluto_ai-1.0.0.dist-info/RECORD,,

pluto_ai-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pluto_ai-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+pluto = pluto.cli:cli

pluto_ai-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+pluto