cmdexy 1.0.0__py3-none-any.whl

cmdexy/cli/interactive.py

@@ -0,0 +1,28 @@
+from rich.console import Console
+from cmdexy.core.controller import Controller
+import asyncio
+
+console = Console()
+
+async def interactive_session():
+    """Start the interactive AI session."""
+    try:
+        controller = Controller()
+    except Exception as e:
+        console.print(f"[bold red]Error:[/bold red] {e}")
+        return
+
+    console.print("[bold green]Welcome to cmdexy![/bold green] Type 'exit' to quit.")
+    
+    while True:
+        try:
+            user_input = console.input("[bold blue]cmdexy >[/bold blue] ")
+            if user_input.lower() in ("exit", "quit"):
+                break
+            
+            await controller.process_input(user_input)
+            
+        except KeyboardInterrupt:
+            break
+        except Exception as e:
+            console.print(f"[bold red]Error:[/bold red] {e}")

cmdexy/cli/run.py

@@ -0,0 +1,10 @@
+from cmdexy.core.controller import Controller
+import asyncio
+
+async def run_instruction(instruction: str):
+    """Execute a single instruction."""
+    try:
+        controller = Controller()
+        await controller.process_input(instruction)
+    except Exception as e:
+        print(f"Error: {e}")

cmdexy/cli/wrapper.py

@@ -0,0 +1,42 @@
+import sys
+from rich.console import Console
+from cmdexy.core.controller import Controller
+from cmdexy.core.execution import ExecutionEngine
+import asyncio
+
+console = Console()
+
+async def execute_wrapper(command_parts: list[str]):
+    """
+    Directly execute a command and monitor for failure.
+    If it fails, trigger AI error recovery.
+    """
+    controller = Controller()
+    
+    # Reconstruct command
+    cmd = " ".join(command_parts)
+    
+    # console.print(f"[dim]Executing: {cmd}[/dim]")
+    
+    # Execute directly
+    exit_code, stdout, stderr = await controller.execution.run_shell_command(cmd)
+    
+    # Identify if output should be printed based on successful execution or not?
+    # Actually run_shell_command buffers output. For a wrapper we ideally want streaming.
+    # But for MVP we just print result.
+    
+    if exit_code == 0:
+        if stdout: print(stdout)
+        if stderr: print(stderr, file=sys.stderr)
+    else:
+        # Failure case
+        if stdout: print(stdout)
+        if stderr: print(stderr, file=sys.stderr)
+        
+        console.print(f"\n[bold red]Command Failed (Exit Code {exit_code})[/bold red]")
+        
+        # Trigger Recovery
+        try:
+            await controller.trigger_error_recovery(cmd, stdout, stderr)
+        except Exception as e:
+            console.print(f"[red]Error during recovery:[/red] {e}")

cmdexy/core/ai_engine.py

@@ -0,0 +1,132 @@
+import cohere
+import os
+from dotenv import load_dotenv
+
+load_dotenv()
+
+from .config import ConfigManager
+
+class AIEngine:
+    def __init__(self):
+        self.config = ConfigManager()
+        api_key = self.config.get_api_key()
+        if not api_key:
+            raise ValueError(
+                "API Key not found or configured.\n"
+                "Please run 'cmdexy config' to set it.\n"
+                "Get your key from: https://dashboard.cohere.com/api-keys"
+            )
+        self.client = cohere.Client(api_key)
+
+    async def analyze_intent(self, user_input: str) -> str:
+        """
+        Simple intent classification using Cohere Chat.
+        """
+        prompt = f"""
+        Classify the following user input into one of these categories:
+        - EXECUTE_CODE: The user wants to write and run code (e.g. "calculate fibonacci", "plot this csv").
+        - SYSTEM_COMMAND: The user wants to run a shell command (e.g. "ls -la", "mkdir foo").
+        - QUESTION: The user is asking a general question.
+
+        Input: "{user_input}"
+        Category:"""
+        
+        response = self.client.chat(
+            model='command-r-08-2024',
+            message=prompt,
+            temperature=0
+        )
+        return response.text.strip()
+
+    async def generate_code(self, instruction: str, language: str = "python") -> str:
+        """
+        Generate a script based on instruction.
+        """
+        prompt = f"""
+        Write a complete, runnable {language} script to: {instruction}.
+        Return ONLY the code, no markdown, no explanation.
+        If using third-party libraries, assume they are installed or standard.
+        """
+        response = self.client.chat(
+            model='command-r-08-2024',
+            message=prompt,
+            temperature=0.3
+        )
+        code = response.text.strip()
+        # Strip markdown fences if present
+        if code.startswith("```"):
+            code = code.split("\n", 1)[1]
+        if code.endswith("```"):
+            code = code.rsplit("\n", 1)[0]
+        # Additional cleanup for fences like ```python
+        if code.startswith("python"):
+            code = code.split("\n", 1)[1]
+        
+        return code.strip()
+
+    async def generate_shell_command(self, instruction: str, os_context: str = "Unknown Linux") -> str:
+        """
+        Generate a shell command based on instruction and OS context.
+        """
+        prompt = f"""
+        You are an expert command line assistant for {os_context}.
+        Write a shell command to: {instruction}.
+        Return ONLY the command, no code blocks, no explanation.
+        Ensure the command is appropriate for the detected OS ({os_context}).
+        
+        Guidelines:
+        - For creating or writing files with multiple lines, USE Heredoc syntax (cat << 'EOF' > filename).
+        - Avoid long one-line 'echo' chains for complex content.
+        - Ensure the usage of Heredoc is compatible with standard shells (bash/zsh).
+        
+        Example:
+        Input: create hello.py with print hello
+        Output: 
+        cat << 'EOF' > hello.py
+        print("Hello")
+        EOF
+        """
+        response = self.client.chat(
+            model='command-r-08-2024',
+            message=prompt,
+            temperature=0
+        )
+        return response.text.strip()
+
+    async def suggest_fix(self, command: str, error_log: str, context: str = "", os_context: str = "Unknown OS") -> str:
+        """
+        Analyze an error and suggest a fix.
+        Returns text that describes the fix and provides the corrected code block if applicable.
+        """
+        prompt = f"""
+        You are an expert command line assistant for {os_context}.
+        I ran this command: `{command}`
+        It failed with this error:
+        {error_log}
+
+        {f"Context: {context}" if context else ""}
+
+        Analyze the error.
+        If the error is in the code file (e.g. syntax error, name error):
+        1. Explain the fix briefly.
+        2. Provide the COMPLETELY CORRECTED file content wrapped in <FILE_CONTENT> tags. 
+        Example:
+        <FILE_CONTENT>
+        def foo():
+            return 1
+        </FILE_CONTENT>
+        
+        If it's a 'command not found' error or tool missing error, YOU MUST PROVIDE the installation command wrapped in <COMMAND_FIX>.
+        Example:
+        <COMMAND_FIX>
+        brew install cowsay
+        </COMMAND_FIX>
+
+        If it's just a wrong flag (e.g. ls -z), provide the corrected command in a standard code block.
+        """
+        response = self.client.chat(
+            model='command-r-08-2024', 
+            message=prompt,
+            temperature=0
+        )
+        return response.text.strip()

cmdexy/core/config.py

@@ -0,0 +1,39 @@
+import os
+import json
+import platform
+from pathlib import Path
+
+class ConfigManager:
+    def __init__(self):
+        self.config_dir = Path.home() / ".cmdexy"
+        self.config_file = self.config_dir / "config.json"
+        self.config = self._load_config()
+        
+    def _load_config(self):
+        if not self.config_file.exists():
+            return {}
+        try:
+            with open(self.config_file, 'r') as f:
+                return json.load(f)
+        except Exception:
+            return {}
+
+    def save_config(self, key: str, value: str):
+        self.config_dir.mkdir(parents=True, exist_ok=True)
+        self.config[key] = value
+        with open(self.config_file, 'w') as f:
+            json.dump(self.config, f, indent=2)
+        # Restrict permissions to owner only (0600 = rw-------)
+        os.chmod(self.config_file, 0o600)
+
+    def get_api_key(self):
+        # Priority: Env Var > Config File
+        return os.getenv("COHERE_API_KEY") or self.config.get("api_key")
+
+    def get_os_context(self):
+        # We compute this live but could cache it
+        system = platform.system()
+        if system == "Darwin":
+            # Return clearer macOS string for AI
+            return f"macOS {platform.mac_ver()[0]} ({platform.machine()})"
+        return f"{system} {platform.release()} ({platform.machine()})"

cmdexy/core/controller.py

@@ -0,0 +1,152 @@
+from rich.console import Console
+from cmdexy.core.ai_engine import AIEngine
+from cmdexy.core.execution import ExecutionEngine
+import platform
+import os
+
+console = Console()
+
+class Controller:
+    def __init__(self):
+        self.ai = AIEngine()
+        self.execution = ExecutionEngine()
+        self.os_context = f"{platform.system()} {platform.release()} ({platform.machine()})"
+
+    async def process_input(self, user_input: str):
+        # 1. Analyze Intent
+        with console.status("[bold green]Acting...[/bold green]"):
+            intent = await self.ai.analyze_intent(user_input)
+        
+        console.print(f"Intent detected: [bold cyan]{intent}[/bold cyan]")
+        
+        if "EXECUTE_CODE" in intent:
+            with console.status("[bold green]Generating Code...[/bold green]"):
+                code = await self.ai.generate_code(user_input)
+            
+            console.print("[bold]Generated Code:[/bold]")
+            console.print(code, style="italic")
+            
+            confirm = console.input("[yellow]Execute? (y/n): [/yellow]")
+            if confirm.lower() == 'y':
+                result = await self.execution.execute_code("python", code)
+                console.print("[bold]Result:[/bold]")
+                console.print(result)
+            else:
+                console.print("[red]Aborted.[/red]")
+
+        elif "SYSTEM_COMMAND" in intent:
+            with console.status("[bold green]Generating Command...[/bold green]"):
+                cmd = await self.ai.generate_shell_command(user_input, self.os_context)
+            
+            console.print(f"Generated Command: [bold yellow]{cmd}[/bold yellow]")
+            
+            confirm = console.input("[yellow]Execute on HOST? (y/n): [/yellow]")
+            if confirm.lower() == 'y':
+                exit_code, stdout, stderr = await self.execution.run_shell_command(cmd)
+                
+                if exit_code == 0:
+                    console.print(stdout)
+                else:
+                    if stdout: console.print(stdout)
+                    console.print(f"[bold red]Command Failed (Exit Code {exit_code})[/bold red]")
+                    if stderr: console.print(stderr, style="red")
+                    
+                    
+                    # Interactive Error Recovery
+                    await self.trigger_error_recovery(cmd, stdout, stderr)
+        
+        else:
+            # QUESTION
+            # CoHere Client is synchronous by default unless AsyncClient is used
+            ans = self.ai.client.chat(message=user_input, model='command-r-08-2024')
+            console.print(f"[bold]AI Answer:[/bold] {ans.text}")
+
+    async def trigger_error_recovery(self, cmd: str, stdout: str, stderr: str):
+        """
+        Public method to trigger the AI error analysis and fix loop.
+        Useful for direct command execution wrapper.
+        """
+        analyze = console.input("[yellow]Analyze Error? (y/n): [/yellow]")
+        if analyze.lower() == 'y':
+            with console.status("[bold yellow]Analyzing Error & Generating Fix...[/bold yellow]"):
+                # If the command involved a file, try to read it for context
+                # Generalized heuristic: check every word in valid command args
+                file_context = ""
+                filename = None
+                
+                # Split command into words and check if they exist as files
+                parts = cmd.split()
+                for part in parts:
+                    # Clean potential quotes or flags
+                    candidate = part.strip("'\"")
+                    if os.path.isfile(candidate):
+                        try:
+                            with open(candidate, 'r') as f:
+                                # Read content to check encoding and capture context
+                                content = f.read()
+                                
+                            filename = candidate
+                            file_context = f"\nFile '{filename}' content:\n{content}"
+                            # Found a valid text file, use it as context
+                            break
+                        except UnicodeDecodeError:
+                            # Skip binary files (like executables)
+                            continue
+                
+                fix_suggestion = await self.ai.suggest_fix(cmd, stderr + stdout, file_context, self.os_context)
+            
+            console.print("[bold]AI Suggestion:[/bold]")
+            console.print(fix_suggestion, style="cyan")
+            
+            # Extract code block via XML tags (robust)
+            new_code = None
+            if "<FILE_CONTENT>" in fix_suggestion:
+                try:
+                    new_code = fix_suggestion.split("<FILE_CONTENT>")[1].split("</FILE_CONTENT>")[0].strip()
+                    # Strip markdown fences if inside tags
+                    if new_code.startswith("```"):
+                        new_code = new_code.split("\n", 1)[1]
+                    if new_code.endswith("```"):
+                        new_code = new_code.rsplit("\n", 1)[0]
+                    if new_code.startswith("python"): # simplified
+                        new_code = new_code[6:].lstrip()
+                except IndexError:
+                    pass
+            
+            if new_code and filename:
+                apply_fix = console.input(f"[bold green]Apply fix to {filename} and retry? (y/n): [/bold green]")
+                if apply_fix.lower() == 'y':
+                    with open(filename, 'w') as f:
+                        f.write(new_code)
+                    console.print(f"[green]Fixed {filename}. Retrying...[/green]")
+                    # Let's just run it once more
+                    # Note: For wrapper mode, this retry executes via shell on host
+                    exit_code, stdout, stderr = await self.execution.run_shell_command(cmd)
+                    if stdout: console.print(stdout)
+                    if exit_code != 0:
+                         console.print(f"[bold red]Retry Failed (Exit Code {exit_code})[/bold red]")
+                         if stderr: console.print(stderr, style="red")
+                         await self.trigger_error_recovery(cmd, stdout, stderr)
+            else:
+                # Check for Command Fix
+                fix_cmd = None
+                if "<COMMAND_FIX>" in fix_suggestion:
+                    try:
+                        fix_cmd = fix_suggestion.split("<COMMAND_FIX>")[1].split("</COMMAND_FIX>")[0].strip()
+                    except IndexError:
+                        pass
+                
+                if fix_cmd:
+                    run_fix = console.input(f"[bold green]Run fix command: '{fix_cmd}'? (y/n): [/bold green]")
+                    if run_fix.lower() == 'y':
+                        console.print(f"[green]Running fix...[/green]")
+                        await self.execution.run_shell_command(fix_cmd)
+                        console.print(f"[green]Fix applied. Retrying original command...[/green]")
+                        exit_code, stdout, stderr = await self.execution.run_shell_command(cmd)
+                        if stdout: console.print(stdout)
+                        if exit_code != 0:
+                             console.print(f"[bold red]Retry Failed (Exit Code {exit_code})[/bold red]")
+                             if stderr: console.print(stderr, style="red")
+                             await self.trigger_error_recovery(cmd, stdout, stderr)
+        else:
+            console.print("[red]Aborted.[/red]")

cmdexy/core/execution.py

@@ -0,0 +1,75 @@
+import docker
+import os
+import asyncio
+from typing import Tuple
+
+class ExecutionEngine:
+    def __init__(self):
+        try:
+            self.client = docker.from_env()
+        except:
+            print("Warning: Docker not available. Sandboxed execution will be limited.")
+            self.client = None
+
+    async def execute_code(self, language: str, code: str) -> str:
+        """
+        Execute code in a sandbox (Docker).
+        Handles interactive scripts by running in foreground if input() detected.
+        """
+        if not self.client:
+            return "Error: Docker not running."
+
+        # Support mainly Python for MVP
+        image = "python:3.10-slim" 
+        
+        # Interactive Mode Check
+        if "input(" in code:
+            # We must run this attached to the user's terminal
+            # Write code to a temp file on host first
+            temp_file = "temp_script.py"
+            with open(temp_file, "w") as f:
+                f.write(code)
+            
+            # Use subprocess to run docker run -it ...
+            # Mounting current dir to /app so script is accessible
+            cmd = ["docker", "run", "-it", "--rm", "-v", f"{os.getcwd()}:/app", "-w", "/app", image, "python", temp_file]
+            
+            # Using asyncio.create_subprocess_exec doesn't handle stdin/tty well for interactive
+            # So we rely on standard subprocess for interactive session
+            import subprocess
+            try:
+                subprocess.run(cmd)
+                return "Interactive session ended."
+            except Exception as e:
+                return f"Interactive Execution Failed: {e}"
+            finally:
+                if os.path.exists(temp_file):
+                    os.remove(temp_file)
+
+        # Standard Detached Execution
+        try:
+            container = self.client.containers.run(
+                image,
+                command=f"python -c '{code}'",
+                remove=True,
+                detach=False, # Wait for output
+                working_dir="/app",
+                stderr=True
+            )
+            return container.decode("utf-8")
+        except Exception as e:
+            return f"Execution Failed: {e}"
+
+    async def run_shell_command(self, command: str) -> Tuple[int, str, str]:
+        """
+        Execute a shell command on the HOST system.
+        Returns (exit_code, stdout, stderr).
+        """
+        process = await asyncio.create_subprocess_shell(
+            command,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE
+        )
+        
+        stdout, stderr = await process.communicate()
+        return process.returncode, stdout.decode().strip(), stderr.decode().strip()

cmdexy/main.py

@@ -0,0 +1,95 @@
+import sys
+import typer
+import asyncio
+from rich.console import Console
+from typing import List, Optional
+from cmdexy.cli.wrapper import execute_wrapper
+from cmdexy.cli.interactive import interactive_session
+from cmdexy.cli.run import run_instruction
+from cmdexy.core.config import ConfigManager
+
+__version__ = "1.0.0"
+
+def version_callback(value: bool):
+    if value:
+        print(f"cmdexy version {__version__}")
+        raise typer.Exit()
+
+app = typer.Typer(help="cmdexy: AI-powered CLI Assistant", 
+                  context_settings={"help_option_names": ["-h", "--help"]})
+console = Console()
+
+@app.callback(invoke_without_command=True)
+def main(
+    ctx: typer.Context,
+    version: bool = typer.Option(None, "--version", "-v", callback=version_callback, is_eager=True, help="Show version and exit")
+):
+    """
+    cmdexy: AI-powered CLI Assistant
+    
+    Run subcommands: config, int, run, shell
+    """
+    if ctx.invoked_subcommand is None:
+        # Show help if no subcommand
+        console.print("[dim]Use --help for more info[/dim]")
+        ctx.get_help()
+
+@app.command(name="shell", 
+             context_settings={"allow_extra_args": True, "ignore_unknown_options": True})
+def shell_command(ctx: typer.Context):
+    """Run any shell command with AI error recovery. Example: cmdexy shell python3 hello.py"""
+    if not ctx.args:
+        console.print("[red]Usage: cmdexy shell <command> [args...][/red]")
+        raise typer.Exit(1)
+    asyncio.run(execute_wrapper(ctx.args))
+
+def interactive():
+    """Start the interactive AI session."""
+    asyncio.run(interactive_session())
+
+@app.command(name="int", hidden=True)
+def interactive_alias():
+    """Alias for interactive."""
+    asyncio.run(interactive_session())
+
+@app.command()
+def run(instruction: str):
+    """Execute a single instruction."""
+    asyncio.run(run_instruction(instruction))
+
+@app.command()
+def config():
+    """Configure cmdexy (API Key, etc)."""
+    manager = ConfigManager()
+    console.print("[bold]Configure cmdexy[/bold]")
+    
+    # API Key
+    current_key = manager.get_api_key()
+    if current_key:
+        console.print(f"Current API Key: [green]{current_key[:4]}...{current_key[-4:]}[/green]")
+    
+    api_key = console.input("Enter Cohere API Key (leave blank to keep current): ", password=True)
+    if api_key.strip():
+        new_key = api_key.strip()
+        console.print("[yellow]Validating API Key...[/yellow]")
+        try:
+            # Validate by making a lightweight call
+            import cohere
+            client = cohere.Client(new_key)
+            # Use Chat API as Generate is deprecated
+            client.chat(message="hi", model="command-r-08-2024")
+            
+            manager.save_config("api_key", new_key)
+            console.print("[green]API Key valid and saved successfully![/green]")
+        except Exception as e:
+            console.print(f"[bold red]Invalid API Key:[/bold red] {e}")
+            console.print("[red]Key NOT saved.[/red]")
+    else:
+        console.print("[yellow]API Key unchanged.[/yellow]")
+
+def entry_point():
+    """Main entry point."""
+    app()
+
+if __name__ == "__main__":
+    entry_point()

cmdexy-1.0.0.dist-info/METADATA

@@ -0,0 +1,236 @@
+Metadata-Version: 2.4
+Name: cmdexy
+Version: 1.0.0
+Summary: AI-powered CLI assistant with automatic error recovery and code fixing.
+License: MIT
+License-File: LICENSE
+Keywords: cli,ai,assistant,error-recovery,cohere,automation
+Author: Akhilesh S
+Author-email: akhilesh2220@github.com
+Requires-Python: >=3.10,<4.0
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Utilities
+Requires-Dist: cohere (>=4.0.0,<5.0.0)
+Requires-Dist: docker (>=7.0.0,<8.0.0)
+Requires-Dist: pydantic (>=2.0.0,<3.0.0)
+Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
+Requires-Dist: rich (>=13.0.0,<14.0.0)
+Requires-Dist: typer[all] (>=0.21.1,<0.22.0)
+Project-URL: Homepage, https://github.com/akhilesh2220/cmdexy
+Project-URL: Repository, https://github.com/akhilesh2220/cmdexy
+Description-Content-Type: text/markdown
+
+# cmdexy
+
+**AI-powered CLI assistant with automatic error recovery and code fixing.**
+
+[![GitHub](https://img.shields.io/badge/GitHub-akhilesh2220%2Fcmdexy-blue)](https://github.com/akhilesh2220/cmdexy)
+[![Python](https://img.shields.io/badge/Python-3.10%2B-green)](https://python.org)
+[![License](https://img.shields.io/badge/License-MIT-yellow)](LICENSE)
+
+---
+
+## ✨ Features
+
+- 🤖 **AI-Powered Intent Analysis** - Understands what you want to do
+- 🔧 **Automatic Error Recovery** - Detects failures and suggests fixes
+- 📝 **Code Auto-Fixing** - Patches your files automatically
+- 💻 **Shell Command Wrapper** - Monitor any command with AI assistance
+- 🍎 **OS-Aware** - Generates platform-specific commands (macOS, Linux, Windows)
+- 🔐 **Secure Config** - API keys stored safely in `~/.cmdexy/`
+
+---
+
+## 🚀 Installation
+
+### Prerequisites
+- Python 3.10+
+- [Cohere API Key](https://dashboard.cohere.com/api-keys) (free tier available)
+
+### Install from source
+
+```bash
+# Clone the repository
+git clone https://github.com/akhilesh2220/cmdexy.git
+cd cmdexy
+
+# Create virtual environment
+python3 -m venv venv
+source venv/bin/activate  # On Windows: venv\Scripts\activate
+
+# Install dependencies
+pip install -e .
+
+# Configure your API key
+cmdexy config
+```
+
+---
+
+## 📖 Usage
+
+### Configure API Key (First Time)
+```bash
+cmdexy config
+```
+
+### Interactive Mode
+Start an AI-powered shell session:
+```bash
+cmdexy int
+```
+
+Example session:
+```
+cmdexy > create a python file that prints hello world
+Intent detected: SYSTEM_COMMAND
+Generated Command: cat <<EOF > hello.py
+print("Hello, World!")
+EOF
+Execute on HOST? (y/n): y
+```
+
+### Run Single Instructions
+```bash
+cmdexy run "list all files in current directory"
+cmdexy run "create a flask app with one endpoint"
+```
+
+### Shell Wrapper (Error Recovery)
+Run any command with AI-powered error monitoring:
+```bash
+cmdexy shell python3 script.py
+cmdexy shell ansible-playbook deploy.yml
+cmdexy shell npm run build
+```
+
+If the command fails, cmdexy will:
+1. Analyze the error using AI
+2. Suggest a fix (code patch or install command)
+3. Apply the fix automatically (with your permission)
+4. Retry the command
+
+### Check Version
+```bash
+cmdexy --version
+```
+
+---
+
+## 🎯 Commands
+
+| Command | Description |
+|---------|-------------|
+| `cmdexy config` | Configure API key and settings |
+| `cmdexy int` | Start interactive AI session |
+| `cmdexy run "<instruction>"` | Execute a single AI-powered instruction |
+| `cmdexy shell <command>` | Run command with error recovery |
+| `cmdexy --version` | Show version |
+| `cmdexy --help` | Show help |
+
+---
+
+## 🔄 Error Recovery Flow
+
+```
+┌─────────────────┐
+│  Run Command    │
+└────────┬────────┘
+         │
+         ▼
+   ┌───────────┐    Success
+   │  Execute  │────────────► Done
+   └─────┬─────┘
+         │ Failure
+         ▼
+┌─────────────────┐
+│ Analyze Error?  │──── No ───► Exit
+└────────┬────────┘
+         │ Yes
+         ▼
+┌─────────────────┐
+│  AI Analysis    │
+└────────┬────────┘
+         │
+    ┌────┴────┐
+    ▼         ▼
+┌───────┐ ┌───────┐
+│ Code  │ │ Cmd   │
+│ Fix   │ │ Fix   │
+└───┬───┘ └───┬───┘
+    │         │
+    ▼         ▼
+┌─────────────────┐
+│  Apply & Retry  │
+└─────────────────┘
+```
+
+---
+
+## 📁 Project Structure
+
+```
+cmdexy/
+├── cmdexy/
+│   ├── main.py           # CLI entry point
+│   ├── cli/
+│   │   ├── interactive.py  # Interactive mode
+│   │   ├── run.py          # Single instruction mode
+│   │   └── wrapper.py      # Shell wrapper
+│   └── core/
+│       ├── ai_engine.py    # Cohere AI integration
+│       ├── config.py       # Configuration manager
+│       ├── controller.py   # Main orchestration logic
+│       └── execution.py    # Command execution
+├── pyproject.toml
+└── README.md
+```
+
+---
+
+## ⚙️ Configuration
+
+Config is stored in `~/.cmdexy/config.json`:
+
+```json
+{
+  "api_key": "your-cohere-api-key"
+}
+```
+
+You can also use environment variable:
+```bash
+export COHERE_API_KEY="your-key"
+```
+
+---
+
+## 🤝 Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+---
+
+## 📄 License
+
+MIT License - see [LICENSE](LICENSE) for details.
+
+---
+
+## 🙏 Acknowledgments
+
+- [Cohere](https://cohere.com/) for the AI API
+- [Typer](https://typer.tiangolo.com/) for the CLI framework
+- [Rich](https://rich.readthedocs.io/) for beautiful terminal output
+

cmdexy-1.0.0.dist-info/RECORD

@@ -0,0 +1,16 @@
+cmdexy/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cmdexy/cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cmdexy/cli/interactive.py,sha256=5yXFU7BfA2FGi53NbfiC9Qlh-pFnXJ4u6pYPh4YkDS4,835
+cmdexy/cli/run.py,sha256=QOAEZO-dM-S9Z_Q7-Bt6nTHlIKi-CvafVM8gp3-yJHQ,298
+cmdexy/cli/wrapper.py,sha256=nL-QW2z9fvDPPujQorIE9SJWb68239H5_xBfxUpwfb0,1369
+cmdexy/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+cmdexy/core/ai_engine.py,sha256=rt3StIUkxpF9pswahLQ6ULTCVwihIVUwaI528emysF4,4708
+cmdexy/core/config.py,sha256=Di2F8btmGcw2ssLqJFXdbi_itxntFJMXREfMZ-PVgN8,1337
+cmdexy/core/controller.py,sha256=fl91WjtGOhg0GOCurnUDrB0R71GA9Rk5pgDagDeLP7o,7554
+cmdexy/core/execution.py,sha256=KSAEHoE9oWbk___m8GQ14SvUmjy0YMjV2yjF8pJwR7g,2725
+cmdexy/main.py,sha256=b4f791Y-ICgt0jffhPZYm8QZOwAxcInu8r7orPkqBzk,3152
+cmdexy-1.0.0.dist-info/METADATA,sha256=Wv9r-AE8naurvIk1OBWLGyJHQjoMUPt0kqTrc_c1Hfo,6334
+cmdexy-1.0.0.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
+cmdexy-1.0.0.dist-info/entry_points.txt,sha256=lPu84sraJxKdF3gqUUv-Whh2G7W7J-DtW338CMjXLgQ,50
+cmdexy-1.0.0.dist-info/licenses/LICENSE,sha256=mDA3fQorLDqAQb96IX-zfKbwzx0oIj1gSGOvGVOpdBc,1067
+cmdexy-1.0.0.dist-info/RECORD,,

cmdexy-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: poetry-core 2.3.0
+Root-Is-Purelib: true
+Tag: py3-none-any

cmdexy-1.0.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+cmdexy=cmdexy.main:entry_point
+

cmdexy-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Akhilesh S
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.