codeaois 0.2.6__tar.gz → 0.3.1__tar.gz

{codeaois-0.2.6 → codeaois-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codeaois
-Version: 0.2.6
+Version: 0.3.1
 Summary: Advanced AI Developer OS
 Author: Nikhil Nagar
 Requires-Python: >=3.8
@@ -14,6 +14,21 @@ Dynamic: requires-python
 
 # CodeAOIS
 
+# 💻 CodeAOIS (v0.3.0) - Advanced Developer OS
+An elite, autonomous AI operating system for your terminal. CodeAOIS doesn't just chat; it reads your codebase, runs its own code, and fixes its own bugs.
+
+## 🔥 Core Pillars
+1. **Global Cloud Identity:** Secure, OTP-based login via private SMTP. Your history, developer profile, and token usage follow you to any machine via Supabase.
+2. **Autonomous Execution Loop:** The OS executes generated Python scripts locally. If it hits a `Traceback` error, it autonomously feeds the crash data back to the LLM and self-corrects the code.
+3. **Local Codebase Brain (RAG):** Type `/index` to calculate embeddings for your entire local project. CodeAOIS instantly retrieves semantic context so you never have to copy-paste your code again.
+4. **LLM Supervisor Engine:** An intelligent routing system that determines if you want to chat, execute a terminal command, or write a new script, routing tasks to specialized agents seamlessly.
+
+## ⚡ Quick Start
+```bash
+pip install -r requirements.txt
+codeaois
+```
+
 ### Advanced AI Developer Operating System
 
 CodeAOIS is an experimental **AI-powered developer operating system** that allows developers to interact with an AI coding system directly from the terminal.

{codeaois-0.2.6 → codeaois-0.3.1}/README.md

@@ -1,5 +1,20 @@
 # CodeAOIS
 
+# 💻 CodeAOIS (v0.3.0) - Advanced Developer OS
+An elite, autonomous AI operating system for your terminal. CodeAOIS doesn't just chat; it reads your codebase, runs its own code, and fixes its own bugs.
+
+## 🔥 Core Pillars
+1. **Global Cloud Identity:** Secure, OTP-based login via private SMTP. Your history, developer profile, and token usage follow you to any machine via Supabase.
+2. **Autonomous Execution Loop:** The OS executes generated Python scripts locally. If it hits a `Traceback` error, it autonomously feeds the crash data back to the LLM and self-corrects the code.
+3. **Local Codebase Brain (RAG):** Type `/index` to calculate embeddings for your entire local project. CodeAOIS instantly retrieves semantic context so you never have to copy-paste your code again.
+4. **LLM Supervisor Engine:** An intelligent routing system that determines if you want to chat, execute a terminal command, or write a new script, routing tasks to specialized agents seamlessly.
+
+## ⚡ Quick Start
+```bash
+pip install -r requirements.txt
+codeaois
+```
+
 ### Advanced AI Developer Operating System
 
 CodeAOIS is an experimental **AI-powered developer operating system** that allows developers to interact with an AI coding system directly from the terminal.

codeaois-0.3.1/codeaois/agents/coder_agent.py

@@ -0,0 +1,46 @@
+from codeaois.models.llm_interface import call_openrouter
+from rich.console import Console
+import time
+
+console = Console()
+
+def generate_code(user_input, full_context=""):
+    """Multi-Agent Swarm that plans, writes, and reviews code."""
+    
+    # --- AGENT 1: THE ARCHITECT ---
+    console.print(f"[dim]🧠 [Architect] Drafting system blueprint...[/dim]")
+    architect_sys = "You are a Senior Software Architect. Break the user's request down into a strict, bulleted, step-by-step implementation plan. Identify the best programming language if not specified. Do NOT write code. Only write the logical plan."
+    plan = call_openrouter(architect_sys, f"REQUEST: {user_input}\nCONTEXT: {full_context}", intent="chat", history=[])
+    
+    # Let the free API cool down!
+    time.sleep(8) 
+    
+    # --- AGENT 2: THE DEVELOPER ---
+    console.print(f"[dim]💻 [Developer] Writing code based on blueprint...[/dim]")
+    dev_sys = "You are an Elite Polyglot Software Engineer. Write the complete, functional code based EXACTLY on the Architect's plan. Return ONLY the final code inside a markdown block. Do not add explanations."
+    dev_prompt = f"ARCHITECT PLAN:\n{plan}\n\nWrite the code."
+    raw_code = call_openrouter(dev_sys, dev_prompt, intent="code", history=[])
+    
+    # Let the free API cool down again!
+    time.sleep(8) 
+    
+    # --- AGENT 3: THE QA TESTER ---
+    console.print(f"[dim]🔎 [QA Tester] Auditing code for bugs and syntax errors...[/dim]")
+    qa_sys = "You are a strict QA Code Reviewer. Review the provided code for logic errors, missing dependencies, or syntax issues. Fix any issues found. Return ONLY the final, perfect code inside a markdown block. No explanations."
+    qa_prompt = f"ORIGINAL REQUEST: {user_input}\n\nDRAFT CODE:\n{raw_code}\n\nReview and return the final bulletproof code."
+    final_code = call_openrouter(qa_sys, qa_prompt, intent="code", history=[])
+    
+    console.print("[bold green]✓ Swarm consensus reached![/bold green]")
+    
+    return final_code
+
+def generate_lite_code(user_input, full_context=""):
+    """Single-shot coder that bypasses the Swarm to prevent API rate limits."""
+    console.print(f"[dim]⚡ [Fast Coder] Writing code in a single shot...[/dim]")
+    
+    dev_sys = """You are an Elite Software Engineer. Write the complete, functional code requested by the user. 
+    You MUST output the target filename at the very top of your response (e.g., `### Filename: clock.html`).
+    Then, provide ONLY the final code inside a markdown block. Do NOT add any conversational text or apologies."""
+    
+    # We use a single API call instead of 3, keeping you perfectly under the free rate limits!
+    return call_openrouter(dev_sys, f"REQUEST: {user_input}\nCONTEXT: {full_context}", intent="code", history=[])

codeaois-0.3.1/codeaois/agents/researcher_agent.py

@@ -0,0 +1,59 @@
+import requests
+from bs4 import BeautifulSoup
+from ddgs import DDGS
+from codeaois.models.llm_interface import call_openrouter
+from rich.console import Console
+
+console = Console()
+
+def search_and_scrape(query, num_results=2):
+    """Searches the web and scrapes the text from the top results."""
+    results_text = ""
+    try:
+        with DDGS() as ddgs:
+            results = list(ddgs.text(query, max_results=num_results))
+            for res in results:
+                url = res.get('href')
+                title = res.get('title')
+                results_text += f"\n--- Source: {title} ({url}) ---\n"
+                
+                try:
+                    # Stealth headers to bypass basic bot-blockers
+                    headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64)'}
+                    page = requests.get(url, headers=headers, timeout=5)
+                    soup = BeautifulSoup(page.content, 'html.parser')
+                    
+                    # Grab all the paragraph text
+                    paragraphs = soup.find_all('p')
+                    text = " ".join([p.get_text() for p in paragraphs])
+                    
+                    # Limit to 2500 characters per site to save your tokens
+                    results_text += text[:2500] + "...\n"
+                except Exception as e:
+                    results_text += f"[Failed to scrape content from {url}]\n"
+    except Exception as e:
+        console.print(f"\n[bold red]✗ Search Engine Crash:[/bold red] {e}")
+        return "WEB SEARCH FAILED. Tell the user you cannot search the internet due to an API error."
+        
+    return results_text
+
+def generate_researcher_code(user_input, full_context=""):
+    """Orchestrates the search, scrape, and synthesis process."""
+    
+    # 1. Ask the AI to figure out exactly what to search for
+    query_prompt = f"Extract the core web search query from this prompt. Reply with ONLY the search string, no quotes.\nPrompt: {user_input}"
+    search_query = call_openrouter("You are a search query extractor.", query_prompt, intent="chat", history=[])
+    search_query = search_query.strip().strip('"').strip("'")
+    
+    console.print(f"[dim]🌐 Searching live web for: [bold white]{search_query}[/bold white][/dim]")
+    
+    # 2. Execute the live web search and scrape the pages
+    web_context = search_and_scrape(search_query)
+    
+    # 3. Feed the live data back to the AI to answer the user
+    console.print(f"[dim]📚 Reading scraped documentation...[/dim]")
+    
+    sys_prompt = "You are an expert AI Researcher with live internet access. Use the provided Web Research to answer the user accurately."
+    final_prompt = f"LATEST WEB RESEARCH:\n{web_context}\n\nUSER REQUEST: {user_input}\nLOCAL CONTEXT:\n{full_context}"
+    
+    return call_openrouter(sys_prompt, final_prompt, intent="chat", history=[])

codeaois-0.3.1/codeaois/agents/scaffolder_agent.py

@@ -0,0 +1,63 @@
+import os
+import json
+import re
+from rich.console import Console
+from codeaois.models.llm_interface import call_openrouter
+
+console = Console()
+
+def generate_scaffolder_code(user_input, full_context=""):
+    """Forces the AI to design a multi-file project architecture and writes it to disk."""
+    console.print("[dim]🏗️  [Scaffolder] Architecting multi-file project structure...[/dim]")
+    
+    sys_prompt = """You are an Expert Software Architect. The user wants to generate a complete, multi-file project.
+    You MUST respond ONLY with a valid JSON object representing the file structure and code. 
+    Do not add conversational text. Only JSON.
+    
+    Format EXACTLY like this:
+    {
+        "project_name": "my_new_app",
+        "files": [
+            {"path": "main.py", "content": "print('hello world')"},
+            {"path": "src/utils.py", "content": "def add(a,b): return a+b"},
+            {"path": "requirements.txt", "content": "requests==2.31.0"}
+        ]
+    }
+    """
+    
+    # Send request to your active AI model
+    response = call_openrouter(sys_prompt, user_input, intent="code", history=[])
+    
+    try:
+        # Extract the JSON even if the AI wraps it in markdown blocks
+        json_str = response.strip()
+        match = re.search(r"```(?:json)?\s*(\{.*\})\s*```", response, re.DOTALL)
+        if match:
+            json_str = match.group(1)
+        else:
+            # Fallback: Find the first { and last }
+            start = response.find('{')
+            end = response.rfind('}') + 1
+            json_str = response[start:end]
+            
+        data = json.loads(json_str)
+        project_name = data.get("project_name", "new_project")
+        files = data.get("files", [])
+        
+        if not files:
+            return "❌ AI didn't return any valid files to generate."
+            
+        console.print(f"\n[bold cyan]📦 Building Project Directory: {project_name}[/bold cyan]")
+        
+        # Build the folders and files!
+        for f in files:
+            file_path = os.path.join(project_name, f["path"])
+            os.makedirs(os.path.dirname(file_path), exist_ok=True) # Create folders if they don't exist
+            with open(file_path, "w", encoding="utf-8") as out_file:
+                out_file.write(f["content"])
+            console.print(f"[green]  + Created: {f['path']}[/green]")
+            
+        return f"### 🏗️ Scaffolding Complete!\nSuccessfully generated `{project_name}` with {len(files)} files and folders."
+        
+    except Exception as e:
+        return f"❌ **Scaffolder JSON Parsing Error:** The AI failed to output valid JSON. Try a smarter coding model.\n*Error: {e}*"

codeaois-0.3.1/codeaois/agents/vision_agent.py

@@ -0,0 +1,45 @@
+import os
+import re
+from playwright.sync_api import sync_playwright
+from rich.console import Console
+from codeaois.models.llm_interface import call_openrouter
+
+console = Console()
+
+def generate_vision_code(user_input, full_context=""):
+    """Opens local HTML files in a headless browser and uses Vision AI to critique the UI."""
+    
+    # Look for an HTML file mentioned in the user's prompt
+    match = re.search(r'([a-zA-Z0-9_\-\.]+\.html)', user_input)
+    if not match:
+        return "❌ Please specify an HTML file to test (e.g., 'look at clock.html')."
+    
+    file_name = match.group(1)
+    file_path = os.path.abspath(file_name)
+    
+    if not os.path.exists(file_path):
+        return f"❌ Could not find {file_name} in the current directory."
+
+    screenshot_path = "debug_screenshot.png"
+    
+    console.print(f"[dim]👁️  [Vision Engine] Launching headless browser to view {file_name}...[/dim]")
+    
+    try:
+        # Spin up the hidden browser and take a picture!
+        with sync_playwright() as p:
+            browser = p.chromium.launch(headless=True)
+            page = browser.new_page()
+            page.goto(f"file://{file_path}")
+            page.screenshot(path=screenshot_path)
+            browser.close()
+    except Exception as e:
+        return f"❌ Headless Browser Error: {e}"
+
+    console.print(f"[dim]📸 [Vision Engine] Screenshot captured! Sending to Vision AI...[/dim]")
+    
+    sys_prompt = "You are an Expert UI/UX Frontend Reviewer. Look at the provided screenshot of the user's web page. Critique the design, layout, alignment, and colors. Point out any visible CSS bugs or ugly elements, and provide the exact CSS code to fix them."
+    
+    # Send the screenshot to your custom AI model! (Requires the updated llm_interface.py from earlier)
+    review = call_openrouter(sys_prompt, user_input, intent="chat", history=[], image_path=screenshot_path)
+    
+    return f"{review}"

codeaois-0.3.1/codeaois/brain/embeddings.py

@@ -0,0 +1,112 @@
+import os
+import json
+import re
+from pathlib import Path
+
+class CodebaseMemory:
+    def __init__(self, project_path="."):
+        self.project_path = Path(project_path)
+        self.db_dir = self.project_path / ".codeaois_db"
+        self.db_file = self.db_dir / "local_index.json"
+        
+        # Folders and files we DO NOT want the AI to read
+        self.ignore_dirs = {".git", "__pycache__", "venv", "env", "node_modules", ".codeaois_db", "dist", "build"}
+        self.ignore_exts = {".pyc", ".png", ".jpg", ".jpeg", ".gif", ".exe", ".dll", ".so", ".pdf", ".zip"}
+
+    def _chunk_text(self, text, max_chars=1500):
+        """Chops large code files into digestible blocks for the AI."""
+        lines = text.split('\n')
+        chunks = []
+        current_chunk = ""
+        
+        for line in lines:
+            if len(current_chunk) + len(line) > max_chars:
+                chunks.append(current_chunk)
+                current_chunk = line + "\n"
+            else:
+                current_chunk += line + "\n"
+                
+        if current_chunk:
+            chunks.append(current_chunk)
+            
+        return chunks
+
+    def index_project(self):
+        """Scans the project, chunks the code, and saves it to the local brain."""
+        self.db_dir.mkdir(exist_ok=True)
+        
+        chunks_indexed = 0
+        index_data = []
+
+        for root, dirs, files in os.walk(self.project_path):
+            # Skip ignored directories and hidden folders
+            dirs[:] = [d for d in dirs if d not in self.ignore_dirs and not d.startswith('.')]
+            
+            for file in files:
+                # Skip ignored extensions and hidden files
+                if any(file.endswith(ext) for ext in self.ignore_exts) or file.startswith('.'):
+                    continue
+                    
+                file_path = Path(root) / file
+                
+                try:
+                    with open(file_path, "r", encoding="utf-8") as f:
+                        content = f.read()
+                        
+                    # Break the file into chunks
+                    chunks = self._chunk_text(content)
+                    
+                    for i, chunk in enumerate(chunks):
+                        index_data.append({
+                            "file": str(file_path.relative_to(self.project_path)),
+                            "chunk_id": i,
+                            "content": chunk
+                        })
+                        chunks_indexed += 1
+                except Exception:
+                    # Silently skip binary files or files with weird encodings
+                    continue 
+
+        # Save the brain to the hidden database folder
+        with open(self.db_file, "w", encoding="utf-8") as f:
+            json.dump(index_data, f, indent=4)
+            
+        return chunks_indexed
+    
+    def search(self, query, top_k=3):
+        """Searches the local JSON brain for chunks matching the user's prompt."""
+        if not self.db_file.exists():
+            return "" # Brain is empty, run /index first
+            
+        try:
+            with open(self.db_file, "r", encoding="utf-8") as f:
+                index_data = json.load(f)
+        except Exception:
+            return ""
+
+        # Simple keyword scoring engine
+        query_words = set(re.findall(r'\w+', query.lower()))
+        # Ignore common filler words
+        stop_words = {"a", "the", "is", "in", "to", "and", "how", "what", "where", "write", "code"}
+        search_words = query_words - stop_words
+        
+        if not search_words:
+            return ""
+
+        scored_chunks = []
+        for item in index_data:
+            chunk_text = item["content"].lower()
+            # Give a point for every matching keyword
+            score = sum(1 for word in search_words if word in chunk_text)
+            if score > 0:
+                scored_chunks.append((score, item))
+
+        # Sort from highest score to lowest
+        scored_chunks.sort(key=lambda x: x[0], reverse=True)
+        
+        # Grab the top results and format them
+        results = []
+        for score, item in scored_chunks[:top_k]:
+            results.append(f"--- Auto-Retrieved Context: {item['file']} ---\n{item['content']}")
+            
+        return "\n\n".join(results)

codeaois-0.3.1/codeaois/brain/scanner.py

@@ -0,0 +1,75 @@
+# codeaois/brain/scanner.py
+import os
+import pathspec
+
+import os
+
+# --- THE CONTEXT SHIELD ---
+IGNORE_DIRS = {".git", "node_modules", "venv", "env", "__pycache__", ".codeaois_db", "build", "dist", ".idea", ".vscode"}
+IGNORE_FILES = {".env", ".DS_Store", "package-lock.json", "yarn.lock"}
+IGNORE_EXTS = {".pyc", ".png", ".jpg", ".jpeg", ".exe", ".dll", ".so", ".zip", ".tar.gz", ".pdf", ".mp4"}
+
+def scan_project_structure(root_dir="."):
+    """Scans the directory tree, but shields the AI from massive junk folders and binary files."""
+    tree_str = ""
+    
+    for root, dirs, files in os.walk(root_dir):
+        # IN-PLACE FILTERING: This physically stops the OS from even looking inside node_modules or .git!
+        dirs[:] = [d for d in dirs if d not in IGNORE_DIRS and not d.startswith('.')]
+        
+        level = root.replace(root_dir, '').count(os.sep)
+        indent = ' ' * 4 * (level)
+        folder_name = os.path.basename(root)
+        
+        if folder_name:
+            tree_str += f"{indent}📂 {folder_name}/\n"
+        
+        subindent = ' ' * 4 * (level + 1)
+        for f in files:
+            # Block secret files and heavy images/binaries
+            if f in IGNORE_FILES or any(f.endswith(ext) for ext in IGNORE_EXTS):
+                continue
+            tree_str += f"{subindent}📄 {f}\n"
+            
+    return tree_str if tree_str else "📂 (Empty Project)"
+class CodeScanner:
+    def __init__(self, root_dir="."):
+        self.root_dir = root_dir
+        # Standard directories and files to ignore globally for RAG Embeddings
+        self.default_ignores = [
+            ".git", "venv", "env", "__pycache__", "node_modules", 
+            ".pytest_cache", "dist", "build", "*.egg-info", 
+            "*.pyc", "*.png", "*.jpg", "*.pdf", ".codeaois_db"
+        ]
+        self.ignore_spec = self._load_gitignore()
+
+    def _load_gitignore(self):
+        """Loads .gitignore if it exists and combines it with defaults."""
+        ignore_patterns = list(self.default_ignores)
+        gitignore_path = os.path.join(self.root_dir, ".gitignore")
+        
+        if os.path.exists(gitignore_path):
+            with open(gitignore_path, "r") as f:
+                ignore_patterns.extend(f.read().splitlines())
+                
+        return pathspec.PathSpec.from_lines('gitwildmatch', ignore_patterns)
+
+    def scan_project(self):
+        """Yields (filepath, content) for all valid code files."""
+        for dirpath, dirnames, filenames in os.walk(self.root_dir):
+            # Filter out ignored directories in-place
+            dirnames[:] = [d for d in dirnames if not self.ignore_spec.match_file(os.path.join(dirpath, d))]
+            
+            for filename in filenames:
+                filepath = os.path.join(dirpath, filename)
+                rel_path = os.path.relpath(filepath, self.root_dir)
+                
+                if self.ignore_spec.match_file(rel_path):
+                    continue
+                    
+                try:
+                    with open(filepath, "r", encoding="utf-8") as f:
+                        yield rel_path, f.read()
+                except UnicodeDecodeError:
+                    # Skip binary files that slipped through
+                    pass