bashexplain 1.0.0__py3-none-any.whl

bash_explain.py

@@ -0,0 +1,613 @@
+"""
+BashExplain - A command-line tool to explain Bash commands, errors, and scripts
+"""
+
+import sys
+import re
+import argparse
+from typing import Dict, List, Tuple, Optional
+from unicodedata import name
+
+
+# Terminal Colors
+
+class Colors:
+    RED     = '\033[91m'
+    GREEN   = '\033[92m'
+    YELLOW  = '\033[93m'
+    BLUE    = '\033[94m'
+    MAGENTA = '\033[95m'
+    CYAN    = '\033[96m'
+    WHITE   = '\033[97m'
+    BOLD    = '\033[1m'
+    DIM     = '\033[2m'
+    RESET   = '\033[0m'
+
+    @staticmethod
+    def disable():
+        """Turn off all colors (when output is piped or --no-color is used)"""
+        Colors.RED = Colors.GREEN = Colors.YELLOW = Colors.BLUE = ''
+        Colors.MAGENTA = Colors.CYAN = Colors.WHITE = ''
+        Colors.BOLD = Colors.DIM = Colors.RESET = ''
+
+
+def clr(color: str, text: str) -> str:
+    """Wrap text in a color code."""
+    return f"{color}{text}{Colors.RESET}"
+
+
+class CommandExplainer:
+    """Explains individual Bash commands and their components"""
+    
+    COMMON_COMMANDS = {
+        'ls': 'List directory contents',
+        'cd': 'Change directory',
+        'pwd': 'Print working directory',
+        'mkdir': 'Make directory',
+        'rmdir': 'Remove empty directory',
+        'rm': 'Remove files or directories',
+        'cp': 'Copy files or directories',
+        'mv': 'Move or rename files',
+        'cat': 'Concatenate and display file contents',
+        'grep': 'Search for patterns in text',
+        'find': 'Search for files in directory hierarchy',
+        'chmod': 'Change file permissions',
+        'chown': 'Change file owner and group',
+        'sudo': 'Execute command as superuser',
+        'apt': 'Package manager (Debian/Ubuntu)',
+        'yum': 'Package manager (RedHat/CentOS)',
+        'systemctl': 'Control systemd services',
+        'ps': 'Report process status',
+        'kill': 'Send signal to process',
+        'top': 'Display running processes',
+        'echo': 'Display text or variables',
+        'export': 'Set environment variable',
+        'source': 'Execute commands from file in current shell',
+        'tar': 'Archive files',
+        'gzip': 'Compress files',
+        'gunzip': 'Decompress files',
+        'wget': 'Download files from the web',
+        'curl': 'Transfer data from or to a server',
+        'ssh': 'Secure shell remote login',
+        'scp': 'Secure copy files over SSH',
+        'git': 'Version control system',
+        'docker': 'Container platform',
+        'pip': 'Python package installer',
+        'npm': 'Node.js package manager',
+        'touch': 'Create empty file or update timestamp',
+        'head': 'Display first lines of file',
+        'tail': 'Display last lines of file',
+        'less': 'View file contents page by page',
+        'more': 'View file contents page by page (simpler)',
+        'diff': 'Compare files line by line',
+        'sed': 'Stream editor for text transformation',
+        'awk': 'Pattern scanning and text processing',
+        'sort': 'Sort lines of text',
+        'uniq': 'Remove duplicate lines',
+        'wc': 'Word, line, and byte count',
+        'man': 'Display manual pages',
+        'which': 'Show full path of command',
+        'whereis': 'Locate binary, source, and manual page',
+        'alias': 'Create command shortcut',
+        'history': 'Show command history',
+        'df': 'Report file system disk space usage',
+        'du': 'Estimate file space usage',
+        'free': 'Display memory usage',
+        'uname': 'Print system information',
+        'hostname': 'Show or set system hostname',
+        'ping': 'Test network connectivity',
+        'netstat': 'Network statistics',
+        'ifconfig': 'Configure network interface',
+        'ip': 'Show/manipulate routing and network devices',
+    }
+
+    COMMON_FLAGS = {
+        '-a': 'All (include hidden files)',
+        '-l': 'Long format (detailed listing)',
+        '-h': 'Human-readable (sizes in KB, MB, GB)',
+        '-r': 'Recursive (include subdirectories)',
+        '-f': "Force (don't prompt for confirmation)",
+        '-v': 'Verbose (show detailed output)',
+        '-i': 'Interactive (prompt before action)',
+        '-n': 'Numeric (use numbers instead of names)',
+        '-p': 'Parent (create parent directories if needed)',
+        '-R': 'Recursive (uppercase version)',
+        '-d': 'Directory (operate on directory itself)',
+        '-s': 'Silent or summarize',
+        '-u': 'Update or user',
+        '-g': 'Group',
+        '-o': 'Output file',
+        '-e': 'Expression or edit',
+        '-w': 'Word match',
+        '-c': 'Count',
+        '-x': 'Exclude or execute',
+        '-z': 'Compress',
+        '-t': 'Time or timestamp',
+        '-k': 'Kill or kilobytes',
+        '-m': 'Modify or message',
+        '-q': 'Quiet (suppress output)',
+        '-y': 'Yes (assume yes to prompts)',
+        '-b': 'Backup',
+        '--help': 'Display help information',
+        '--version': 'Display version information',
+        '--force': 'Force operation (do not prompt for confirmation)',
+        '--recursive': 'Operate recursively (same as -r)',
+        '--no-preserve-root': 'Do not treat "/" as special for "rm -rf" (dangerous)',
+        '--dry-run': 'Show what would be done without making changes',
+        '--no-clobber': 'Do not overwrite existing files',
+        '--verbose': 'Show detailed output (same as -v)',
+        '--quiet': 'Suppress most output (same as -q)',
+    }
+
+    UNSAFE_PATTERNS = [
+        (r'rm\s+-rf\s+/', 'DANGEROUS: This will delete files starting from root directory'),
+        (r'rm\s+-rf\s+--no-preserve-root', 'EXTREMELY DANGEROUS: Overrides safety and can delete the entire filesystem'),
+        (r'rm\s+-rf\s+\.', 'DANGEROUS: Deletes the current directory recursively'),
+        (r'rm\s+-rf\s+\*', 'DANGEROUS: Deletes all files in the current directory'),
+        (r'chmod\s+777', 'UNSAFE: Grants full permissions to everyone'),
+        (r'curl\s+.*\|\s*bash', 'RISKY: Executing downloaded script without inspection'),
+        (r'curl\s+-sSL\s+.*\|\s*sh', 'RISKY: Silent download-and-execute without inspection'),
+        (r'wget\s+.*\|\s*sh', 'RISKY: Executing downloaded script without inspection'),
+        (r'wget\s+-qO-.*\|\s*bash', 'RISKY: Silent download-and-execute without inspection'),
+        (r'sudo\s+chmod', 'CAUTION: Changing permissions as superuser'),
+        (r'sudo\s+rm', 'CAUTION: Deleting files as superuser'),
+        (r':\(\)\{.*\};:', 'DANGEROUS: Fork bomb - will crash system'),
+        (r'dd\s+if=.*of=/dev/(?:sd|nvme|mmcblk)\b', 'DANGEROUS: Writing raw data to a disk device'),
+        (r'fdisk\s+/dev/(?:sd|nvme|mmcblk)', 'DANGEROUS: Partitioning can destroy existing data'),
+        (r'mkfs\.?', 'DANGEROUS: Formatting disk - will erase all data'),
+        (r'echo\s+.*>\s*/etc/passwd', 'DANGEROUS: Overwriting system password file'),
+        (r'kill\s+-9\s+1\b', 'DANGEROUS: Killing init process may crash the system'),
+        (r'iptables\s+-F', 'CAUTION: Flushing firewall rules may break connectivity'),
+        (r'systemctl\s+stop\s+ssh', 'CAUTION: Stopping SSH may lock you out of remote servers'),
+        (r'chown\s+-R\s+root:root\s+/', 'CAUTION: Recursively changing ownership of root can break permissions'),
+        (r'>\s*/dev/(?:sd|nvme|mmcblk)', 'DANGEROUS: Redirecting output to a disk device can overwrite it'),
+        (r'cat\s+/dev/zero\s*>\s*/dev/(?:sd|nvme|mmcblk)', 'DANGEROUS: Overwriting disk with zeros'),
+        (r'nohup\s+.*&\s*$', 'CAUTION: Backgrounding processes without control may leave unmanaged jobs'),
+    ]
+
+    def explain_command(self, command: str) -> str:
+        """Explain a Bash command in detail"""
+        command = command.strip()
+        
+        if not command:
+            return "No command provided."
+        
+        output = []
+        output.append(clr(Colors.BOLD + Colors.BLUE, f"📝 Explaining: {command}") + "\n")
+        
+        # Check for unsafe patterns
+        warnings = self._check_safety(command)
+        if warnings:
+            output.append(clr(Colors.RED + Colors.BOLD, "⚠️  SAFETY WARNINGS:"))
+            for warning in warnings:
+                output.append(clr(Colors.RED, f"   {warning}"))
+            output.append("")
+        
+        # Parse the command
+        parts = self._parse_command(command)
+        
+        # Explain main command
+        if parts['command']:
+            cmd_name = parts['command']
+            cmd_desc = self.COMMON_COMMANDS.get(cmd_name, 'Custom command or script')
+            output.append(clr(Colors.CYAN + Colors.BOLD, f"🔧 Command: {cmd_name}"))
+            output.append(clr(Colors.DIM, f"   {cmd_desc}") + "\n")
+        
+        # Explain flags
+        if parts['flags']:
+            output.append(clr(Colors.YELLOW + Colors.BOLD, "🚩 Flags:"))
+            for flag in parts['flags']:
+                flag_desc = self.COMMON_FLAGS.get(flag, self._guess_flag_meaning(flag))
+                output.append(f"   {clr(Colors.YELLOW, flag)} → {flag_desc}")
+            output.append("")
+        
+        # Explain arguments
+        if parts['arguments']:
+            output.append(clr(Colors.GREEN + Colors.BOLD, "📂 Arguments:"))
+            for i, arg in enumerate(parts['arguments'], 1):
+                arg_type = self._identify_argument_type(arg)
+                output.append(f"   {i}. {clr(Colors.GREEN, arg)} ({arg_type})")
+            output.append("")
+        
+        # Explain pipes
+        if parts['pipes']:
+            output.append(clr(Colors.MAGENTA + Colors.BOLD, "🔀 Pipes:"))
+            output.append("   Commands are chained - output of one becomes input of next")
+            for i, pipe_cmd in enumerate(parts['pipes'], 1):
+                output.append(f"   {i}. {clr(Colors.MAGENTA, pipe_cmd)}")
+            output.append("")
+        
+        # Explain redirections
+        if parts['redirections']:
+            output.append(clr(Colors.BLUE + Colors.BOLD, "↩️  Redirections:"))
+            for redir in parts['redirections']:
+                output.append(f"   {clr(Colors.BLUE, redir['symbol'])} {clr(Colors.GREEN, redir['target'])} → {redir['description']}")
+            output.append("")
+        
+        # Add educational note
+        output.append(clr(Colors.GREEN, "💡 Tip: Use 'man <command>' for detailed documentation"))
+        
+        return "\n".join(output)
+
+    def _parse_command(self, command: str) -> Dict:
+        """Parse command into components"""
+        result = {
+            'command': None,
+            'flags': [],
+            'arguments': [],
+            'pipes': [],
+            'redirections': []
+        }
+        
+        # Check for pipes
+        if '|' in command:
+            pipe_parts = command.split('|')
+            result['pipes'] = [p.strip() for p in pipe_parts]
+            command = pipe_parts[0].strip()  # Process first part
+        
+        # Check for redirections
+        redir_patterns = [
+            (r'>>?\s*(\S+)', 'redirect output to file'),
+            (r'2>>?\s*(\S+)', 'redirect errors to file'),
+            (r'&>>?\s*(\S+)', 'redirect both output and errors to file'),
+            (r'<\s*(\S+)', 'read input from file'),
+        ]
+        
+        for pattern, desc in redir_patterns:
+            matches = re.finditer(pattern, command)
+            for match in matches:
+                symbol = match.group(0).split()[0]
+                target = match.group(1)
+                result['redirections'].append({
+                    'symbol': symbol,
+                    'target': target,
+                    'description': desc
+                })
+                command = command.replace(match.group(0), '')
+        
+        # Split into tokens
+        tokens = command.split()
+        
+        if not tokens:
+            return result
+        
+        # First token is usually the command
+        result['command'] = tokens[0]
+        
+        # Process remaining tokens
+        for token in tokens[1:]:
+            if token.startswith('-'):
+                result['flags'].append(token)
+            else:
+                result['arguments'].append(token)
+        
+        return result
+
+    def _check_safety(self, command: str) -> List[str]:
+        """Check for unsafe command patterns"""
+        warnings = []
+        for pattern, warning in self.UNSAFE_PATTERNS:
+            if re.search(pattern, command):
+                warnings.append(warning)
+        return warnings
+    
+    def _guess_flag_meaning(self, flag: str) -> str:
+        """Guess the meaning of an unknown flag"""
+        if flag.startswith('--'):
+            name = flag[2:].replace('-', ' ')
+            return f"Long option: {name}"
+        elif flag.startswith('-') and len(flag) > 2:
+            return "Combined short options: " + ", ".join(f"-{c}" for c in flag[1:])
+        return "Option (see 'man' for details)"
+
+    def _identify_argument_type(self, arg: str) -> str:
+        """Identify what type of argument this is"""
+        if arg.startswith('/'):
+            return "Absolute path"
+        elif arg.startswith('~'):
+            return "Home directory path"
+        elif arg.startswith('./') or arg.startswith('../'):
+            return "Relative path"
+        elif '/' in arg:
+            return "Path"
+        elif arg.startswith('$'):
+            return "Variable"
+        elif arg.startswith('"') or arg.startswith("'"):
+            return "String literal"
+        elif arg.isdigit():
+            return "Number"
+        elif '*' in arg or '?' in arg:
+            return "Glob pattern"
+        else:
+            return "Filename or value"
+        
+class ErrorExplainer:
+    """Explains common Bash and terminal errors"""
+    
+    ERROR_PATTERNS = {
+        r'command not found': {
+            'explanation': 'The shell cannot find the command you typed.',
+            'causes': [
+                'Typo in command name',
+                'Command not installed on system',
+                'Command not in PATH environment variable',
+                'Missing ./ prefix for local script'
+            ],
+            'solutions': [
+                'Check spelling of command',
+                'Install the required package',
+                'Use full path to command',
+                'For local script, use: ./script.sh'
+            ]
+        },
+        r'Permission denied': {
+            'explanation': "You don't have permission to perform this operation.",
+            'causes': [
+                'File is not executable',
+                'Insufficient user permissions',
+                'File/directory owned by another user',
+                'SELinux or AppArmor restrictions'
+            ],
+            'solutions': [
+                'Make file executable: chmod +x filename',
+                'Use sudo if appropriate (be careful!)',
+                'Check file ownership: ls -l filename',
+                'Request access from system administrator'
+            ]
+        },
+        r'No such file or directory': {
+            'explanation': 'The file or directory you specified does not exist.',
+            'causes': [
+                'Typo in filename or path',
+                'File was moved or deleted',
+                'Wrong current directory',
+                'Case sensitivity (Linux is case-sensitive)'
+            ],
+            'solutions': [
+                'Check spelling and case',
+                'Use ls to list available files',
+                'Use pwd to verify current directory',
+                'Use absolute path instead of relative'
+            ]
+        },
+        r'syntax error': {
+            'explanation': 'The shell found invalid syntax in your command or script.',
+            'causes': [
+                'Missing quotes or brackets',
+                'Unclosed string or command substitution',
+                'Invalid operator or special character',
+                'Wrong syntax for control structure'
+            ],
+            'solutions': [
+                'Check for matching quotes and brackets',
+                'Review Bash syntax documentation',
+                'Use shellcheck to validate scripts',
+                'Break complex commands into simpler parts'
+            ]
+        },
+        r'cannot remove.*Directory not empty': {
+            'explanation': 'Cannot delete directory because it contains files.',
+            'causes': [
+                'Using rmdir on non-empty directory',
+                'Directory contains hidden files'
+            ],
+            'solutions': [
+                'Use rm -r to remove directory and contents',
+                'Use rm -ri for interactive deletion (safer)',
+                'Check for hidden files with ls -la'
+            ]
+        },
+        r'Disk quota exceeded': {
+            'explanation': 'You have exceeded your allocated disk space.',
+            'causes': [
+                'Too many files or large files',
+                'Disk quota policy on system'
+            ],
+            'solutions': [
+                'Delete unnecessary files',
+                'Check disk usage: du -sh *',
+                'Contact administrator for quota increase'
+            ]
+        },
+        r'Text file busy': {
+            'explanation': 'Cannot modify file because it is being executed.',
+            'causes': [
+                'Trying to edit or delete running script/binary',
+                'File is currently in use by a process'
+            ],
+            'solutions': [
+                'Stop the running process first',
+                'Use ps aux | grep filename to find process',
+                'Kill process with: kill <PID>'
+            ]
+        },
+    }
+
+    def explain_error(self, error_message: str) -> str:
+        """Explain a Bash error message"""
+        output = []
+        output.append(clr(Colors.RED + Colors.BOLD, f"🔴 Error Message: {error_message}") + "\n")
+        
+        # Find matching error pattern
+        matched = False
+        for pattern, info in self.ERROR_PATTERNS.items():
+            if re.search(pattern, error_message, re.IGNORECASE):
+                matched = True
+                output.append(clr(Colors.CYAN + Colors.BOLD, "📖 Explanation:"))
+                output.append(f"   {info['explanation']}\n")
+                
+                output.append(clr(Colors.YELLOW + Colors.BOLD, "🔍 Common Causes:"))
+                for i, cause in enumerate(info['causes'], 1):
+                    output.append(f"   {i}. {cause}")
+                output.append("")
+                
+                output.append(clr(Colors.GREEN + Colors.BOLD, "✅ Possible Solutions:"))
+                for i, solution in enumerate(info['solutions'], 1):
+                    output.append(f"   {i}. {solution}")
+                output.append("")
+                
+                break
+        
+        if not matched:
+            output.append(clr(Colors.DIM, "   This error is not in our database yet."))
+            output.append("   General troubleshooting steps:")
+            output.append("   1. Read the full error message carefully")
+            output.append("   2. Check your command syntax")
+            output.append("   3. Verify file/directory names and paths")
+            output.append("   4. Search online for the specific error")
+            output.append("   5. Check relevant log files")
+            output.append("")
+        
+        output.append(clr(Colors.GREEN, "💡 Tip: Copy the exact error message when searching online"))
+        
+        return "\n".join(output)
+    
+class ScriptExplainer:
+    """Explains Bash scripts line by line"""
+    
+    def explain_script(self, script_path: str) -> str:
+        """Explain a Bash script"""
+        try:
+            with open(script_path, 'r') as f:
+                lines = f.readlines()
+        except FileNotFoundError:
+            return clr(Colors.RED, f"❌ Error: Script file '{script_path}' not found")
+        except PermissionError:
+            return clr(Colors.RED, f"❌ Error: Permission denied reading '{script_path}'")
+        
+        output = []
+        output.append(clr(Colors.CYAN + Colors.BOLD, f"📜 Explaining Script: {script_path}") + "\n")
+        
+        for i, line in enumerate(lines, 1):
+            line = line.rstrip()
+            
+            if not line or line.strip().startswith('#'):
+                # Comment or empty line
+                if line.strip().startswith('#!'):
+                    output.append(clr(Colors.DIM, f"{i:3d} | ") + clr(Colors.MAGENTA + Colors.BOLD, line))
+                    output.append(clr(Colors.DIM, "      ↳ Shebang: Tells system which interpreter to use") + "\n")
+                elif line.strip().startswith('#'):
+                    output.append(clr(Colors.DIM, f"{i:3d} | {line}"))
+                    output.append(clr(Colors.DIM, "      ↳ Comment: Explanation for humans, ignored by shell") + "\n")
+                else:
+                    output.append(clr(Colors.DIM, f"{i:3d} | {line}") + "\n")
+            else:
+                output.append(clr(Colors.DIM, f"{i:3d} | ") + line)
+                explanation = self._explain_line(line.strip())
+                if explanation:
+                    output.append(clr(Colors.DIM, "      ↳ ") + clr(Colors.GREEN, explanation) + "\n")
+        
+        return "\n".join(output)
+
+    def _explain_line(self, line: str) -> str:
+        """Explain a single line of script"""
+        # Variable assignment
+        if '=' in line and not line.startswith('if') and not line.startswith('['):
+            if line.split('=')[0].strip().isidentifier():
+                var_name = line.split('=')[0].strip()
+                return f"Assigns value to variable '{var_name}'"
+        
+        # Conditionals
+        if line.startswith('if'):
+            return "Conditional: Executes code if condition is true"
+        if line.startswith('elif'):
+            return "Else-if: Alternative condition if previous was false"
+        if line.startswith('else'):
+            return "Else: Executes if all conditions were false"
+        if line.startswith('fi'):
+            return "Ends if statement"
+        
+        # Loops
+        if line.startswith('for'):
+            return "For loop: Iterates over a list of items"
+        if line.startswith('while'):
+            return "While loop: Repeats while condition is true"
+        if line.startswith('until'):
+            return "Until loop: Repeats until condition becomes true"
+        if line.startswith('done'):
+            return "Ends loop"
+        
+        # Functions
+        if '()' in line and '{' in line:
+            func_name = line.split('()')[0].strip()
+            return f"Defines function '{func_name}'"
+        
+        # Case statement
+        if line.startswith('case'):
+            return "Case statement: Matches value against patterns"
+        if line.startswith('esac'):
+            return "Ends case statement"
+        
+        # Common commands
+        if line.startswith('echo'):
+            return "Prints text or variables to terminal"
+        if line.startswith('read'):
+            return "Reads input from user into variable"
+        if line.startswith('exit'):
+            return "Exits script with status code"
+        if line.startswith('return'):
+            return "Returns from function with status code"
+        
+        # Brackets and tests
+        if line.startswith('[') or line.startswith('[['):
+            return "Test condition (checks if something is true)"
+        
+        return "Executes command (see command explanation for details)"
+
+def main():
+    parser = argparse.ArgumentParser(
+        description='BashExplain - Understand Bash commands, errors, and scripts',
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  bashexplain command "ls -lah /home"
+  bashexplain error "bash: command not found"
+  bashexplain script myscript.sh
+        """
+    )
+
+    parser.add_argument(
+        '--no-color', action='store_true',
+        help='Disable colored output (useful when piping)'
+    )
+    
+    subparsers = parser.add_subparsers(dest='mode', help='Mode of operation')
+    
+    # Command mode
+    cmd_parser = subparsers.add_parser('command', help='Explain a Bash command')
+    cmd_parser.add_argument('command', nargs='+', help='Command to explain')
+    
+    # Error mode
+    err_parser = subparsers.add_parser('error', help='Explain an error message')
+    err_parser.add_argument('message', nargs='+', help='Error message to explain')
+    
+    # Script mode
+    script_parser = subparsers.add_parser('script', help='Explain a Bash script')
+    script_parser.add_argument('file', help='Script file to explain')
+    
+    args = parser.parse_args()
+
+    # Disable color when piping or --no-color flag is used
+    if args.no_color or not sys.stdout.isatty():
+        Colors.disable()
+    
+    if not args.mode:
+        parser.print_help()
+        return
+    
+    if args.mode == 'command':
+        command = ' '.join(args.command)
+        explainer = CommandExplainer()
+        print(explainer.explain_command(command))
+    
+    elif args.mode == 'error':
+        error = ' '.join(args.message)
+        explainer = ErrorExplainer()
+        print(explainer.explain_error(error))
+    
+    elif args.mode == 'script':
+        explainer = ScriptExplainer()
+        print(explainer.explain_script(args.file))
+
+if __name__ == '__main__':
+    main()

bashexplain-1.0.0.dist-info/METADATA

@@ -0,0 +1,88 @@
+Metadata-Version: 2.4
+Name: bashexplain
+Version: 1.0.0
+Summary: A command-line tool to explain Bash commands, errors, and scripts
+Author-email: Ashish Singh <ashishsingh.mail26@gmail.com>, Ravi Poddar <ravipoddar2006@gmail.com>
+Project-URL: Homepage, https://github.com/singhashish12238-pixel/bash-explain
+Project-URL: Bug Tracker, https://github.com/singhashish12238-pixel/bash-explain/issues
+Project-URL: Source Code, https://github.com/singhashish12238-pixel/bash-explain
+Project-URL: Documentation, https://github.com/singhashish12238-pixel/bash-explain#readme
+Keywords: bash,shell,terminal,cli,education,learning,command-line
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: System Administrators
+Classifier: Topic :: Education
+Classifier: Topic :: System :: Shells
+Classifier: Topic :: Utilities
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.6
+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
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+Provides-Extra: dev
+Requires-Dist: pytest>=6.0; extra == "dev"
+Requires-Dist: black>=21.0; extra == "dev"
+Requires-Dist: flake8>=3.9; extra == "dev"
+Requires-Dist: twine>=4.0; extra == "dev"
+Requires-Dist: build>=0.10; extra == "dev"
+
+# Bash Explain
+
+A Python-based tool for explaining Bash commands with intelligent parsing, flag recognition, and security analysis. Helps developers understand command syntax and identify potentially dangerous operations.
+
+## Features Implemented
+
+### Command Explanation Engine
+- Parses and explains bash commands with detailed breakdowns
+- 60+ common commands with descriptions across multiple categories
+
+### Flag & Option Recognition  
+- 40+ common flag patterns (e.g., `-a`, `-r`, `-v`, `--help`)
+- Automatic meaning identification
+
+### Security Analysis
+- Detects 24+ dangerous command patterns
+- Warns about destructive operations, unsafe downloads, permission changes
+- Identifies fork bombs, system modifications, and more
+
+### Command Parsing
+- Extracts flags, arguments, pipes, and redirections
+- Classifies argument types
+- Handles custom commands
+
+## Technology
+
+- **Language**: Python 3
+- **Design**: OOP with `CommandExplainer` class
+- **Dependencies**: Standard library only
+- **Method**: Pattern matching and rule-based analysis
+
+## Completed
+
+✅ Command explanation engine  
+✅ Command & flag database  
+✅ Safety pattern detection system  
+✅ Command parser & output formatting  
+✅ Type hints for code maintainability  
+
+## Coming Soon
+
+🔄 Interactive REPL mode  
+🔄 Script file analysis  
+🔄 Configuration support  
+🔄 Extended command database  
+
+## Authors
+
+- Ashish Singh
+- Ravi Poddar

bashexplain-1.0.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+bash_explain.py,sha256=rKpeJdHl0QjvN480JU5hge2vHBMYTlUxxeVYy9udtbc,25281
+bashexplain-1.0.0.dist-info/METADATA,sha256=hqW1-vZxUhBDb_ff005BXSIrXxl_Hikoqmoo4dZHEic,3227
+bashexplain-1.0.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+bashexplain-1.0.0.dist-info/entry_points.txt,sha256=1wAa28C8jn4-Uwe79ZIxCzTfeJOI0JDQiTpp5hdv-ek,50
+bashexplain-1.0.0.dist-info/top_level.txt,sha256=PjxUnrt3_r5xPpUGKYjkf5ApTDsIKh4_j51GX3S9h6M,13
+bashexplain-1.0.0.dist-info/RECORD,,

bashexplain-1.0.0.dist-info/WHEEL

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

bashexplain-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+bashexplain = bash_explain:main

bashexplain-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+bash_explain