quasar-ai 1.0.0__tar.gz

quasar_ai-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Sunil Kumawat
+
+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.

quasar_ai-1.0.0/PKG-INFO

@@ -0,0 +1,126 @@
+Metadata-Version: 2.4
+Name: quasar-ai
+Version: 1.0.0
+Summary: 🚀 QUASAR - AI-powered CLI code editor with agentic capabilities
+Author: Sunil Kumawat
+License: MIT
+Project-URL: Homepage, https://github.com/sunilkumawat/quasar-ai
+Project-URL: Documentation, https://github.com/sunilkumawat/quasar-ai#readme
+Project-URL: Repository, https://github.com/sunilkumawat/quasar-ai
+Keywords: ai,cli,code-editor,llm,agent,langchain
+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: Topic :: Software Development :: Code Generators
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer>=0.9.0
+Requires-Dist: rich>=13.0.0
+Requires-Dist: fastapi>=0.109.0
+Requires-Dist: uvicorn[standard]>=0.27.0
+Requires-Dist: python-multipart>=0.0.6
+Requires-Dist: pydantic>=2.5.0
+Requires-Dist: python-dotenv>=1.0.0
+Requires-Dist: langchain>=0.1.0
+Requires-Dist: langchain-core>=0.1.0
+Requires-Dist: langchain-openai>=0.0.5
+Requires-Dist: langchain-groq>=0.0.1
+Requires-Dist: langchain-ollama>=0.0.1
+Requires-Dist: websockets>=12.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: twine; extra == "dev"
+Dynamic: license-file
+
+# 🚀 QUASAR - AI-Powered CLI Code Editor
+
+An intelligent command-line assistant that can understand your codebase, generate code, fix bugs, and execute tasks using AI.
+
+## Installation
+
+```bash
+pip install quasar-ai
+```
+
+## Setup API Keys
+
+**IMPORTANT**: You must provide your own API keys. QUASAR does not include any API keys.
+
+Set at least ONE of these environment variables:
+
+```bash
+# Groq (recommended - fast inference)
+export GROQ_API_KEY_1="gsk_your_key_here"
+
+# Cerebras
+export CEREBRAS_API_KEY_1="csk_your_key_here"
+
+# OpenAI
+export OPENAI_API_KEY="sk-your_key_here"
+```
+
+**Get free API keys:**
+- Groq: https://console.groq.com
+- Cerebras: https://cloud.cerebras.ai
+- OpenAI: https://platform.openai.com
+
+### Multiple Keys (Optional)
+For higher rate limits, add multiple keys per provider:
+```bash
+export GROQ_API_KEY_1="gsk_..."
+export GROQ_API_KEY_2="gsk_..."
+```
+
+## Usage
+
+### Interactive Mode (REPL)
+```bash
+quasar
+# or
+quasar --interactive
+```
+
+### Single Command
+```bash
+quasar "create a hello.py file that prints Hello World"
+quasar "explain main.py"
+quasar "fix the bug in utils.py"
+quasar "list files in current directory"
+```
+
+### Specify Workspace
+```bash
+quasar --workspace /path/to/project "add tests for api.py"
+```
+
+## Supported Tasks
+
+QUASAR automatically classifies your request and uses the best model:
+
+| Task | Example |
+|------|---------|
+| Chat | "What is machine learning?" |
+| Code Generation | "Create a REST API endpoint" |
+| Bug Fixing | "Fix the TypeError in app.py" |
+| Code Explanation | "Explain this function" |
+| Refactoring | "Improve the structure of utils.py" |
+| Documentation | "Add docstrings to main.py" |
+| Test Generation | "Write tests for calculator.py" |
+
+## Updating
+
+```bash
+pip install --upgrade quasar-ai
+```
+
+## License
+
+MIT License

quasar_ai-1.0.0/README.md

@@ -0,0 +1,84 @@
+# 🚀 QUASAR - AI-Powered CLI Code Editor
+
+An intelligent command-line assistant that can understand your codebase, generate code, fix bugs, and execute tasks using AI.
+
+## Installation
+
+```bash
+pip install quasar-ai
+```
+
+## Setup API Keys
+
+**IMPORTANT**: You must provide your own API keys. QUASAR does not include any API keys.
+
+Set at least ONE of these environment variables:
+
+```bash
+# Groq (recommended - fast inference)
+export GROQ_API_KEY_1="gsk_your_key_here"
+
+# Cerebras
+export CEREBRAS_API_KEY_1="csk_your_key_here"
+
+# OpenAI
+export OPENAI_API_KEY="sk-your_key_here"
+```
+
+**Get free API keys:**
+- Groq: https://console.groq.com
+- Cerebras: https://cloud.cerebras.ai
+- OpenAI: https://platform.openai.com
+
+### Multiple Keys (Optional)
+For higher rate limits, add multiple keys per provider:
+```bash
+export GROQ_API_KEY_1="gsk_..."
+export GROQ_API_KEY_2="gsk_..."
+```
+
+## Usage
+
+### Interactive Mode (REPL)
+```bash
+quasar
+# or
+quasar --interactive
+```
+
+### Single Command
+```bash
+quasar "create a hello.py file that prints Hello World"
+quasar "explain main.py"
+quasar "fix the bug in utils.py"
+quasar "list files in current directory"
+```
+
+### Specify Workspace
+```bash
+quasar --workspace /path/to/project "add tests for api.py"
+```
+
+## Supported Tasks
+
+QUASAR automatically classifies your request and uses the best model:
+
+| Task | Example |
+|------|---------|
+| Chat | "What is machine learning?" |
+| Code Generation | "Create a REST API endpoint" |
+| Bug Fixing | "Fix the TypeError in app.py" |
+| Code Explanation | "Explain this function" |
+| Refactoring | "Improve the structure of utils.py" |
+| Documentation | "Add docstrings to main.py" |
+| Test Generation | "Write tests for calculator.py" |
+
+## Updating
+
+```bash
+pip install --upgrade quasar-ai
+```
+
+## License
+
+MIT License

quasar_ai-1.0.0/backend/__init__.py

@@ -0,0 +1,5 @@
+"""
+QUASAR AI - CLI Code Editor Package
+"""
+
+__version__ = "1.0.0"

quasar_ai-1.0.0/backend/cli.py

@@ -0,0 +1,248 @@
+#!/usr/bin/env python
+"""
+QUASAR CLI - Terminal-based AI Code Editor
+
+Usage:
+    quasar "your prompt here"           # Single command mode
+    quasar --interactive                # REPL mode
+    quasar --help                       # Show help
+"""
+
+import asyncio
+import os
+import sys
+from pathlib import Path
+from typing import Optional
+
+import typer
+from rich.console import Console
+from rich.live import Live
+from rich.markdown import Markdown
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from rich.syntax import Syntax
+from rich.text import Text
+
+# Add parent to path for imports
+sys.path.insert(0, str(Path(__file__).parent))
+
+from services.agent.orchestrator import Orchestrator
+from services.agent.models import CredentialManager
+
+app = typer.Typer(
+    name="quasar",
+    help="🚀 QUASAR - AI-powered CLI code editor",
+    add_completion=False,
+)
+console = Console()
+
+# Global orchestrator
+_orchestrator: Optional[Orchestrator] = None
+
+
+def get_orchestrator() -> Orchestrator:
+    """Get or create orchestrator instance."""
+    global _orchestrator
+    if _orchestrator is None:
+        _orchestrator = Orchestrator()
+    return _orchestrator
+
+
+def check_api_keys() -> bool:
+    """Check if any API keys are configured."""
+    cred_manager = CredentialManager()
+    status = cred_manager.get_status()
+    
+    available = [name for name, info in status.items() if info.get("has_credentials")]
+    
+    if not available or available == ["ollama"]:
+        console.print(Panel(
+            "[bold red]⚠️  No API keys found![/bold red]\n\n"
+            "Please set at least one of these environment variables:\n\n"
+            "  [green]GROQ_API_KEY_1[/green]=gsk_...\n"
+            "  [green]CEREBRAS_API_KEY_1[/green]=csk_...\n"
+            "  [green]OPENAI_API_KEY_1[/green]=sk_...\n\n"
+            "You can add multiple keys: GROQ_API_KEY_2, etc.\n\n"
+            "[dim]Get API keys at:[/dim]\n"
+            "  Groq: https://console.groq.com\n"
+            "  Cerebras: https://cloud.cerebras.ai",
+            title="Setup Required",
+            border_style="red"
+        ))
+        return False
+    
+    console.print(f"[dim]✓ Available providers: {', '.join(available)}[/dim]")
+    return True
+
+
+async def process_query(query: str, workspace: str) -> None:
+    """Process a single query and stream the response."""
+    orchestrator = get_orchestrator()
+    orchestrator.set_workspace(workspace)
+    
+    response_text = ""
+    current_tool = None
+    
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[progress.description]{task.description}"),
+        console=console,
+        transient=True,
+    ) as progress:
+        task_id = progress.add_task("Thinking...", total=None)
+        
+        try:
+            async for chunk in orchestrator.process_stream(query=query):
+                chunk_type = chunk.get("type", "")
+                
+                if chunk_type == "classification":
+                    task_type = chunk.get("task_type", "unknown")
+                    progress.update(task_id, description=f"[cyan]Task: {task_type}[/cyan]")
+                
+                elif chunk_type == "iteration":
+                    current = chunk.get("current", 1)
+                    max_iter = chunk.get("max", 30)
+                    progress.update(task_id, description=f"[yellow]Iteration {current}/{max_iter}[/yellow]")
+                
+                elif chunk_type == "tool_start":
+                    tool_name = chunk.get("tool", "unknown")
+                    current_tool = tool_name
+                    progress.update(task_id, description=f"[blue]🔧 {tool_name}...[/blue]")
+                
+                elif chunk_type == "tool_complete":
+                    tool_name = chunk.get("tool", current_tool or "tool")
+                    console.print(f"  [green]✓[/green] {tool_name}")
+                    current_tool = None
+                
+                elif chunk_type == "message":
+                    # Progress/observation messages
+                    msg = chunk.get("content", "")
+                    if msg:
+                        progress.update(task_id, description=f"[dim]{msg[:60]}...[/dim]" if len(msg) > 60 else f"[dim]{msg}[/dim]")
+                
+                elif chunk_type == "token":
+                    # Streaming response text - collect it
+                    token = chunk.get("content", "")
+                    response_text += token
+                    # Stop the spinner when we start getting response
+                    if response_text and len(response_text) < 10:
+                        progress.stop()
+                
+                elif chunk_type == "error":
+                    error_msg = chunk.get("message", "Unknown error")
+                    console.print(f"[red]❌ Error: {error_msg}[/red]")
+                    return
+                
+                elif chunk_type == "done":
+                    # Final summary
+                    model = chunk.get("model", "unknown")
+                    provider = chunk.get("provider", "unknown")
+                    tools_used = chunk.get("tools_used", [])
+                    tool_count = chunk.get("tool_calls_count", 0)
+                    
+                    # Print the response
+                    if response_text:
+                        console.print()
+                        console.print(Markdown(response_text))
+                    
+                    # Print summary
+                    console.print()
+                    summary = f"[dim]Model: {provider}/{model}"
+                    if tool_count > 0:
+                        summary += f" | Tools: {tool_count}"
+                    summary += "[/dim]"
+                    console.print(summary)
+                    return
+        
+        except KeyboardInterrupt:
+            console.print("\n[yellow]Cancelled[/yellow]")
+        except Exception as e:
+            console.print(f"[red]Error: {e}[/red]")
+
+
+def run_repl(workspace: str) -> None:
+    """Run interactive REPL mode."""
+    console.print(Panel(
+        "[bold cyan]🚀 QUASAR AI Editor[/bold cyan]\n\n"
+        f"[dim]Workspace: {workspace}[/dim]\n\n"
+        "Type your requests, or:\n"
+        "  [green]/help[/green]  - Show commands\n"
+        "  [green]/quit[/green]  - Exit\n"
+        "  [green]/clear[/green] - Clear screen",
+        border_style="cyan"
+    ))
+    
+    while True:
+        try:
+            console.print()
+            query = console.input("[bold green]>[/bold green] ").strip()
+            
+            if not query:
+                continue
+            
+            # Handle special commands
+            if query.lower() in ["/quit", "/exit", "/q"]:
+                console.print("[dim]Goodbye![/dim]")
+                break
+            elif query.lower() == "/clear":
+                console.clear()
+                continue
+            elif query.lower() == "/help":
+                console.print(Panel(
+                    "[bold]Commands:[/bold]\n"
+                    "  /quit, /exit, /q - Exit REPL\n"
+                    "  /clear - Clear screen\n"
+                    "  /help - Show this help\n\n"
+                    "[bold]Examples:[/bold]\n"
+                    '  "Create a hello.py file"\n'
+                    '  "Explain main.py"\n'
+                    '  "Fix the bug in utils.py"\n'
+                    '  "List files in current directory"',
+                    title="Help",
+                    border_style="blue"
+                ))
+                continue
+            
+            # Process the query
+            asyncio.run(process_query(query, workspace))
+            
+        except KeyboardInterrupt:
+            console.print("\n[dim]Use /quit to exit[/dim]")
+        except EOFError:
+            console.print("\n[dim]Goodbye![/dim]")
+            break
+
+
+@app.command()
+def main(
+    query: Optional[str] = typer.Argument(None, help="Query to process"),
+    interactive: bool = typer.Option(False, "--interactive", "-i", help="Run in interactive REPL mode"),
+    workspace: str = typer.Option(None, "--workspace", "-w", help="Workspace directory (default: current dir)"),
+):
+    """
+    🚀 QUASAR - AI-powered CLI code editor
+    
+    Examples:
+        quasar "create a hello.py file"
+        quasar "explain main.py"
+        quasar --interactive
+    """
+    # Set workspace
+    if workspace is None:
+        workspace = os.getcwd()
+    workspace = str(Path(workspace).resolve())
+    
+    # Check for API keys
+    if not check_api_keys():
+        raise typer.Exit(1)
+    
+    if interactive or query is None:
+        # REPL mode
+        run_repl(workspace)
+    else:
+        # Single command mode
+        asyncio.run(process_query(query, workspace))
+
+
+if __name__ == "__main__":
+    app()

quasar_ai-1.0.0/backend/logging_config.py

@@ -0,0 +1,199 @@
+"""
+Global Logging Module for AI Code Editor Backend
+
+Provides centralized logging for all backend components:
+- API requests/responses
+- File operations
+- Terminal operations
+- Agent operations
+- WebSocket connections
+
+All logs are written to: backend/logs/
+"""
+
+import logging
+import sys
+import os
+from pathlib import Path
+from datetime import datetime
+from functools import wraps
+import time
+
+
+# Create logs directory
+LOGS_DIR = Path(__file__).parent / "logs"
+LOGS_DIR.mkdir(exist_ok=True)
+
+# Log files
+MAIN_LOG = LOGS_DIR / f"backend_{datetime.now().strftime('%Y%m%d')}.log"
+ERROR_LOG = LOGS_DIR / f"errors_{datetime.now().strftime('%Y%m%d')}.log"
+
+
+def setup_logger(name: str, level: int = logging.DEBUG) -> logging.Logger:
+    """
+    Setup a logger with file and console handlers.
+    
+    Args:
+        name: Logger name (e.g., 'files', 'terminal', 'agent')
+        level: Logging level
+        
+    Returns:
+        Configured logger
+    """
+    logger = logging.getLogger(name)
+    
+    # Avoid duplicate handlers
+    if logger.handlers:
+        return logger
+    
+    logger.setLevel(level)
+    
+    # File handler - detailed logs
+    file_handler = logging.FileHandler(MAIN_LOG, encoding='utf-8')
+    file_handler.setLevel(logging.DEBUG)
+    file_formatter = logging.Formatter(
+        '%(asctime)s | %(levelname)-8s | %(name)-15s | %(funcName)-20s | %(message)s',
+        datefmt='%Y-%m-%d %H:%M:%S'
+    )
+    file_handler.setFormatter(file_formatter)
+    
+    # Error file handler - errors only
+    error_handler = logging.FileHandler(ERROR_LOG, encoding='utf-8')
+    error_handler.setLevel(logging.ERROR)
+    error_handler.setFormatter(file_formatter)
+    
+    # Console handler - silent (CRITICAL only) to keep CLI clean
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(logging.CRITICAL)
+    console_formatter = logging.Formatter(
+        '%(levelname)s: [%(name)s] %(message)s'
+    )
+    console_handler.setFormatter(console_formatter)
+    
+    logger.addHandler(file_handler)
+    logger.addHandler(error_handler)
+    logger.addHandler(console_handler)
+    
+    return logger
+
+
+# Pre-configured loggers for each module
+api_logger = setup_logger("api")
+files_logger = setup_logger("files")
+terminal_logger = setup_logger("terminal")
+execute_logger = setup_logger("execute")
+agent_logger = setup_logger("agent")
+ws_logger = setup_logger("websocket")
+
+
+def log_request(logger: logging.Logger):
+    """
+    Decorator to log API request/response.
+    
+    Usage:
+        @log_request(api_logger)
+        async def my_endpoint():
+            ...
+    """
+    def decorator(func):
+        @wraps(func)
+        async def wrapper(*args, **kwargs):
+            start = time.time()
+            func_name = func.__name__
+            
+            # Log request
+            logger.info(f"📥 Request: {func_name}")
+            if kwargs:
+                logger.debug(f"Parameters: {kwargs}")
+            
+            try:
+                result = await func(*args, **kwargs)
+                elapsed = (time.time() - start) * 1000
+                logger.info(f"📤 Response: {func_name} ({elapsed:.0f}ms)")
+                return result
+                
+            except Exception as e:
+                elapsed = (time.time() - start) * 1000
+                logger.error(f"❌ Error in {func_name} ({elapsed:.0f}ms): {type(e).__name__}: {e}")
+                raise
+                
+        return wrapper
+    return decorator
+
+
+def log_operation(logger: logging.Logger, operation: str):
+    """
+    Context manager for logging operations.
+    
+    Usage:
+        with log_operation(files_logger, "read_file"):
+            contents = read_file(path)
+    """
+    class OperationLogger:
+        def __init__(self):
+            self.start = None
+            
+        def __enter__(self):
+            self.start = time.time()
+            logger.debug(f"➡️ Starting: {operation}")
+            return self
+            
+        def __exit__(self, exc_type, exc_val, exc_tb):
+            elapsed = (time.time() - self.start) * 1000
+            if exc_type:
+                logger.error(f"❌ Failed: {operation} ({elapsed:.0f}ms) - {exc_type.__name__}: {exc_val}")
+            else:
+                logger.debug(f"✅ Completed: {operation} ({elapsed:.0f}ms)")
+            return False
+            
+    return OperationLogger()
+
+
+# Convenience functions
+def log_file_operation(operation: str, path: str, success: bool = True, error: str = None):
+    """Log file operation."""
+    if success:
+        files_logger.info(f"📁 {operation}: {path}")
+    else:
+        files_logger.error(f"❌ {operation} failed: {path} - {error}")
+
+
+def log_terminal_command(command: str, exit_code: int = None):
+    """Log terminal command."""
+    if exit_code is None:
+        terminal_logger.info(f"💻 Running: {command[:100]}")
+    else:
+        status = "✅" if exit_code == 0 else "❌"
+        terminal_logger.info(f"{status} Command finished (exit {exit_code}): {command[:50]}")
+
+
+def log_websocket_event(event: str, client_id: str = None, data: str = None):
+    """Log WebSocket event."""
+    ws_logger.info(f"🔌 WS {event}" + (f" [{client_id}]" if client_id else ""))
+    if data:
+        ws_logger.debug(f"Data: {data[:200]}")
+
+
+def log_agent_event(event: str, details: str = None):
+    """Log agent event."""
+    agent_logger.info(f"🤖 {event}")
+    if details:
+        agent_logger.debug(f"Details: {details}")
+
+
+# Export all
+__all__ = [
+    "setup_logger",
+    "log_request",
+    "log_operation",
+    "api_logger",
+    "files_logger", 
+    "terminal_logger",
+    "execute_logger",
+    "agent_logger",
+    "ws_logger",
+    "log_file_operation",
+    "log_terminal_command",
+    "log_websocket_event",
+    "log_agent_event"
+]