Upload 11 files

.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+*.swp
+.env

Dockerfile

@@ -1,20 +1,20 @@
-FROM python:3.13.5-slim
+FROM python:3.11-slim
 
 WORKDIR /app
 
+COPY . /app
+
 RUN apt-get update && apt-get install -y \
-    build-essential \
-    curl \
     git \
+    curl \
     && rm -rf /var/lib/apt/lists/*
 
-COPY requirements.txt ./
-COPY src/ ./src/
-
-RUN pip3 install -r requirements.txt
 
-EXPOSE 8501
+RUN pip install --no-cache-dir \
+    grpcio==1.60.1 \
+    google-generativeai \
+    python-dotenv
 
-HEALTHCHECK CMD curl --fail http://localhost:8501/_stcore/health
+ENV PYTHONUNBUFFERED=1
 
-ENTRYPOINT ["streamlit", "run", "src/streamlit_app.py", "--server.port=8501", "--server.address=0.0.0.0"]
+CMD ["python", "main.py"]

README.md

@@ -1,19 +1,53 @@
----
-title: AI Code Terminal
-emoji: 🚀
-colorFrom: red
-colorTo: red
-sdk: docker
-app_port: 8501
-tags:
-- streamlit
-pinned: false
-short_description: Streamlit template space
----
-
-# Welcome to Streamlit!
-
-Edit `/src/streamlit_app.py` to customize this app to your heart's desire. :heart:
-
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
+AI Coding Terminal
+A custom AI-powered coding shell that builds, edits, and manages projects directly from natural language commands. Designed for developers who want to interact with code through conversational prompts, integrating LLMs, Docker, and advanced terminal features.
+
+Features
+Custom Shell & Cursor: Fully interactive terminal with a custom cursor and intelligent command handling.
+
+AI-Powered Code Generation: Integrates Gemini API to interpret natural language and generate or edit Python projects.
+
+Project Management: Build, edit, and organize projects from a single terminal interface.
+
+Docker Integration: Run isolated environments for safe and reproducible code execution.
+
+Extensible & Modular: Easily add new commands, AI models, or workflows.
+
+Cross-Platform: Works in Linux, macOS, and Windows environments supporting Python and Docker.
+
+Tech Stack
+Languages: Python
+
+APIs: Gemini LLM API
+
+Containerization: Docker
+
+Terminal Control: Custom shell implementation with advanced cursor management
+
+Other: Optional extensions for code linting, testing, and deployment
+
+Installation
+Clone the repository:
+
+git clone https://github.com/Aravindh-dev12/Codic--AI-Coding-Terminal.git
+cd ai-coding-terminal
+Install dependencies:
+
+pip install -r requirements.txt
+Configure Gemini API key:
+
+export GEMINI_API_KEY="your_api_key_here"
+Run Docker setup (optional for isolated environments):
+
+docker-compose up
+Usage
+Start the AI coding terminal:
+
+python main.py
+Example commands:
+
+create project my_app → Creates a new Python project
+
+add function for user authentication → Adds Python functions based on natural language
+
+refactor code in utils.py → Refactors existing files with AI assistance
+

builtin_commands.py

@@ -0,0 +1,170 @@
+import os
+import getpass
+import socket
+from datetime import datetime
+import curses
+import re
+from colors import *
+from display import clear_and_setup, show_ascii_art
+from gemini_client import ask_gemini, ask_gemini_with_file_generation
+
+def my_ls():
+    try:
+        files = os.listdir('.')
+        print(f"{CYAN}📁 Files and Directories:{RESET}")
+        for item in sorted(files):
+            if os.path.isdir(item):
+                print(f"  {BLUE}{BOLD}📁 {item}/{RESET}")  
+            else:
+                print(f"  {GREEN}📄 {item}{RESET}") 
+    except PermissionError:
+        print(f"{RED}❌ Permission denied{RESET}")
+
+def my_pwd():
+    print(f"{YELLOW}📍 Current directory: {BOLD}{os.getcwd()}{RESET}")
+
+def my_date():
+    now = datetime.now()
+    print(f"{MAGENTA}🕒 {now.strftime('%A, %B %d, %Y - %I:%M:%S %p')}{RESET}")
+
+def my_whoami():
+    username = getpass.getuser()
+    hostname = socket.gethostname()
+    print(f"{CYAN}👤 You are: {BOLD}{username}{RESET} on Acidop shell")
+
+def my_help():
+    print(f"{BOLD}{CYAN}🛠️  codic Built-in Commands:{RESET}")
+    print(f"{GREEN}  ls        {RESET}- List files and directories (custom)")
+    print(f"{GREEN}  pwd       {RESET}- Show current directory (custom)")
+    print(f"{GREEN}  cd <dir>  {RESET}- Change directory")
+    print(f"{GREEN}  date      {RESET}- Show current date and time (custom)")
+    print(f"{GREEN}  whoami    {RESET}- Show current user info (custom)")
+    print(f"{GREEN}  clear     {RESET}- Clear the screen")
+    print(f"{GREEN}  help      {RESET}- Show this help message")
+    print(f"{GREEN}  ascii     {RESET}- Show cool ASCII art")
+    print(f"{GREEN}  exit      {RESET}- Exit the shell")
+    print(f"{GREEN}  ai        {RESET}- Enter AI mode with Gemini 2.5 Flash")
+    print(f"{GREEN}  ai gen    {RESET}- Enter AI mode with automatic file generation")
+    print(f"{YELLOW}  <command> {RESET}- Run any system command")
+
+def handle_builtin_commands(command_parts):
+    cmd = command_parts[0].lower()
+    
+    if cmd == "ls":
+        my_ls()
+        return True
+    elif cmd == "pwd":
+        my_pwd()
+        return True
+    elif cmd == "cd":
+        try:
+            if len(command_parts) == 1:
+                os.chdir(os.path.expanduser("~"))
+            else:
+                os.chdir(command_parts[1])
+            print(f"{GREEN}✅ Changed to: {os.getcwd()}{RESET}")
+        except FileNotFoundError:
+            print(f"{RED}❌ Directory not found: {command_parts[1]}{RESET}")
+        except PermissionError:
+            print(f"{RED}❌ Permission denied{RESET}")
+        return True
+    elif cmd == "date":
+        my_date()
+        return True
+    elif cmd == "whoami":
+        my_whoami()
+        return True
+    elif cmd == "clear":
+        clear_and_setup()
+        return True
+    elif cmd == "help":
+        my_help()
+        return True
+    elif cmd == "ascii":
+        show_ascii_art()
+        return True
+    elif cmd == "ai":
+        if len(command_parts) > 1 and command_parts[1].lower() == "gen":
+            print(f"{YELLOW}🤖 Entering AI Gen Mode (with file generation).{RESET}")
+            print(f"{CYAN}💡 Tip: Ask me to 'create a Flask app' or 'build a React component'{RESET}")
+            print(f"{GREEN}📍 Current directory: {os.getcwd()}{RESET}")
+            print(f"{YELLOW}Type 'exit' to leave.{RESET}\n")
+            
+            while True:
+                query = input(f"{MAGENTA}ai-gen> {RESET}").strip()
+                if query.lower() in ["exit", "quit"]:
+                    print(f"{YELLOW}👋 Leaving AI Gen mode.{RESET}")
+                    break
+                if not query:
+                    continue
+                
+                print(f"{YELLOW}🤖 Thinking and generating...{RESET}\n")
+                
+                print(f"{CYAN}📁 Where should I create the files?{RESET}")
+                print(f"{YELLOW}   Examples:{RESET}")
+                print(f"{YELLOW}   - Press Enter (current directory){RESET}")
+                print(f"{YELLOW}   - my_project (creates folder in current dir){RESET}")
+                print(f"{YELLOW}   - ~/Desktop/my_app (absolute path){RESET}")
+                print(f"{YELLOW}   - ../parent_folder/project (relative path){RESET}")
+                project_dir = input(f"{CYAN}   Path: {RESET}").strip()
+                
+                if not project_dir:
+                    project_dir = "."
+                    print(f"{GREEN}   ✓ Using current directory: {os.getcwd()}{RESET}")
+                else:
+                    project_dir = os.path.expanduser(project_dir)
+      
+                    if not os.path.isabs(project_dir):
+                        abs_path = os.path.abspath(project_dir)
+                        print(f"{GREEN}   ✓ Will create in: {abs_path}{RESET}")
+                    else:
+                        print(f"{GREEN}   ✓ Will create in: {project_dir}{RESET}")
+    
+                    if not os.path.exists(project_dir):
+                        confirm = input(f"{YELLOW}   Directory doesn't exist. Create it? (Y/n): {RESET}").strip().lower()
+                        if confirm and confirm != 'y' and confirm != '':
+                            print(f"{RED}   ✗ Cancelled{RESET}\n")
+                            continue
+                        try:
+                            os.makedirs(project_dir, exist_ok=True)
+                            print(f"{GREEN}   ✓ Created directory{RESET}")
+                        except Exception as e:
+                            print(f"{RED}   ✗ Failed to create directory: {e}{RESET}\n")
+                            continue
+                
+                print() 
+                response, files_generated = ask_gemini_with_file_generation(query, project_dir)
+                
+                clean_response = re.sub(r'<file path="[^"]+">.*?</file>', '', response, flags=re.DOTALL)
+                clean_response = re.sub(r'<command>.*?</command>', '', clean_response, flags=re.DOTALL)
+                clean_response = clean_response.strip()
+                
+                if clean_response:
+                    print(f"\n{GREEN}{clean_response}{RESET}\n")
+                
+                if not files_generated and '<file' not in response:
+                    print(f"{YELLOW}💡 Tip: Ask me to create or generate files!{RESET}\n")
+        
+        elif len(command_parts) == 1:
+            print(f"{YELLOW}🤖 Entering AI mode. Type 'exit' to leave.{RESET}")
+            print(f"{CYAN}💡 Use 'ai gen' for file generation mode{RESET}\n")
+            
+            while True:
+                query = input(f"{CYAN}ai> {RESET}").strip()
+                if query.lower() in ["exit", "quit"]:
+                    print(f"{YELLOW}👋 Leaving AI mode.{RESET}")
+                    break
+                if not query:
+                    continue
+                print(f"{YELLOW}🤖 Thinking...{RESET}")
+                answer = ask_gemini(query)
+                print(f"{GREEN}{answer}{RESET}\n")
+        else:
+            query = " ".join(command_parts[1:])
+            print(f"{YELLOW}🤖 Thinking...{RESET}")
+            answer = ask_gemini(query)
+            print(f"{GREEN}{answer}{RESET}")
+        
+        return True
+    
+    return False

colors.py

@@ -0,0 +1,17 @@
+# colors.py
+
+# Text Colors
+RED = '\033[31m'
+GREEN = '\033[32m'
+YELLOW = '\033[33m'
+BLUE = '\033[34m'
+MAGENTA = '\033[35m'
+CYAN = '\033[36m'
+WHITE = '\033[37m'
+
+# Styles
+BOLD = '\033[1m'
+RESET = '\033[0m'
+
+# Background
+BG_BLACK = '\033[40m'

display.py

@@ -0,0 +1,38 @@
+# display.py
+import os
+import getpass
+import socket
+from datetime import datetime
+from colors import *
+
+def clear_and_setup():
+    """Clear terminal and setup background"""
+    os.system('clear')
+    print(BG_BLACK, end='') 
+    print(f"{CYAN}{BOLD}")
+    print("    ╔═══════════════════════════════════════╗")
+    print("    ║               Codic                   ║") 
+    print("    ║         Your Custom Shell             ║")
+    print("    ╚═══════════════════════════════════════╝")
+    print(f"{RESET}\n")
+
+def get_colored_prompt():
+    """Create colorful prompt with current path"""
+    username = getpass.getuser()
+    hostname = socket.gethostname()
+    current_path = os.getcwd()
+    
+    if len(current_path) > 25:
+        current_path = "..." + current_path[-22:]
+    
+    return f"{GREEN}{BOLD}{username}{RESET}@{BLUE}{hostname}{RESET}:{YELLOW}{BOLD}{current_path}{RESET}> AcidopShell$ "
+
+def show_ascii_art():
+    """Show cool ASCII art as background"""
+    art = f"""{BLUE}
+    ⠀⠀⠀⠀⠀⠀⠀⠀⣀⣤⣶⣿⣿⣿⣿⣿⣶⣤⣀⠀⠀⠀⠀⠀⠀⠀⠀
+    ⠀⠀⠀⠀⠀⣠⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⣄⠀⠀⠀⠀⠀
+    ⠀⠀⠀⢀⣾⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣷⡀⠀⠀⠀
+    ⠀⠀⢠⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡄⠀⠀
+    {RESET}"""
+    print(art)

docker-compose.yml

@@ -0,0 +1,13 @@
+version: '3.8'
+
+services:
+  acidop-shell:
+    build: .
+    container_name: acidop-shell
+    stdin_open: true
+    tty: true
+    env_file:
+      - .env
+    volumes:
+      - .:/app
+    working_dir: /app

external_commands.py

@@ -0,0 +1,14 @@
+# external_commands.py
+import subprocess
+from colors import *
+
+def run_external_command(command_parts):
+    """Run external system commands"""
+    try:
+        result = subprocess.run(command_parts)
+        if result.returncode != 0:
+            print(f"{RED}⚠️  Command exited with code: {result.returncode}{RESET}")
+    except FileNotFoundError:
+        print(f"{RED}❌ Command not found: {command_parts[0]}{RESET}")
+    except KeyboardInterrupt:
+        print(f"{YELLOW}⏸️  Command interrupted{RESET}")

gemini_client.py

@@ -0,0 +1,65 @@
+# gemini_client.py
+import os
+from dotenv import load_dotenv
+import google.generativeai as genai
+from llm_file_generator import file_generator
+
+load_dotenv()
+
+api_key = os.getenv("GEMINI_API_KEY")
+if not api_key:
+    raise ValueError("❌ GEMINI_API_KEY missing. Ensure it's in .env and passed with --env-file")
+
+genai.configure(api_key=api_key)
+
+SYSTEM_INSTRUCTION = f"""You are AcidopShell AI Assistant - a helpful coding assistant integrated into a custom shell.
+You can answer questions, explain concepts, and generate code files.
+
+{file_generator.get_enhanced_prompt()}
+
+Be concise but helpful. When generating files, always provide complete, working code.
+You can provide explanations before or after the XML tags."""
+
+model_with_files = genai.GenerativeModel(
+    "gemini-2.0-flash-exp",
+    system_instruction=SYSTEM_INSTRUCTION
+)
+
+model_regular = genai.GenerativeModel("gemini-2.0-flash-exp")
+
+
+def ask_gemini(prompt: str):
+    """
+    Basic Gemini query - just returns the response text.
+    Use this for simple Q&A without file generation.
+    """
+    try:
+        response = model_regular.generate_content(prompt)
+        return response.text
+    except Exception as e:
+        return f"⚠️ Error: {e}"
+
+
+def ask_gemini_with_file_generation(query: str, project_dir: str = "."):
+    """
+    Enhanced Gemini query with automatic file generation.
+    
+    Args:
+        query: The user's prompt
+        project_dir: Directory where files should be created (default: current dir)
+    
+    Returns:
+        tuple: (response_text, files_were_generated)
+            - response_text: The full response from Gemini
+            - files_were_generated: True if files were created, False otherwise
+    """
+    try:
+        response = model_with_files.generate_content(query)
+        response_text = response.text
+        
+        files_generated = file_generator.process_response(response_text, project_dir)
+        
+        return response_text, files_generated
+        
+    except Exception as e:
+        return f"⚠️ Error: {e}", False

llm_file_generator.py

@@ -0,0 +1,202 @@
+import re
+import subprocess
+from pathlib import Path
+from colors import *
+
+class LLMFileGenerator:
+    """Handles parsing LLM responses and generating real files"""
+    
+    def __init__(self):
+        self.last_files = []
+        self.last_commands = []
+    
+    def parse_response(self, response_text):
+        """
+        Parse LLM response for file generation instructions.
+        Looks for XML tags like:
+        <file path="src/app.js">content</file>
+        <command>npm install</command>
+        """
+        files = []
+        commands = [] 
+        
+        file_pattern = r'<file path="([^"]+)">\s*(.*?)\s*</file>'
+        for match in re.finditer(file_pattern, response_text, re.DOTALL):
+            path = match.group(1).strip()
+            content = match.group(2)
+            files.append({'path': path, 'content': content})
+        
+        command_pattern = r'<command>(.*?)</command>'
+        for match in re.finditer(command_pattern, response_text, re.DOTALL):
+            commands.append(match.group(1).strip())
+        
+        self.last_files = files
+        self.last_commands = commands
+        
+        return files, commands
+    
+    def has_file_instructions(self, response_text):
+        """Check if response contains file generation instructions"""
+        return '<file path=' in response_text or '<command>' in response_text
+    
+    def create_files(self, files, base_dir="."):
+        """Create actual files on disk"""
+        created_files = []
+        
+        if not files:
+            return created_files
+        
+        Path(base_dir).mkdir(parents=True, exist_ok=True)
+        
+        print(f"\n{CYAN}📁 Creating {len(files)} file(s)...{RESET}")
+        
+        for file_info in files:
+            try:
+                file_path = Path(base_dir) / file_info['path']
+                
+                file_path.parent.mkdir(parents=True, exist_ok=True)
+                
+                with open(file_path, 'w', encoding='utf-8') as f:
+                    f.write(file_info['content'])
+                
+                created_files.append(str(file_path))
+                print(f"{GREEN}✓ Created: {file_path}{RESET}")
+                
+            except Exception as e:
+                print(f"{RED}✗ Failed to create {file_info['path']}: {e}{RESET}")
+        
+        return created_files
+    
+    def run_commands(self, commands, cwd="."):
+        """Execute commands in the specified directory"""
+        if not commands:
+            return []
+        
+        print(f"\n{YELLOW}⚙️  Running {len(commands)} command(s)...{RESET}")
+        results = []
+        
+        for cmd in commands:
+            print(f"\n{CYAN}→ Running: {BOLD}{cmd}{RESET}")
+            
+            try:
+                result = subprocess.run(
+                    cmd,
+                    shell=True,
+                    cwd=cwd,
+                    capture_output=True,
+                    text=True,
+                    timeout=300 
+                )
+                
+                if result.returncode == 0:
+                    print(f"{GREEN}✓ Success{RESET}")
+                    if result.stdout.strip():
+                        print(result.stdout)
+                    results.append({
+                        'command': cmd,
+                        'success': True,
+                        'output': result.stdout
+                    })
+                else:
+                    print(f"{RED}✗ Failed with code {result.returncode}{RESET}")
+                    if result.stderr:
+                        print(f"{RED}{result.stderr}{RESET}")
+                    results.append({
+                        'command': cmd,
+                        'success': False,
+                        'error': result.stderr
+                    })
+                    
+            except subprocess.TimeoutExpired:
+                print(f"{RED}✗ Command timed out (5 min limit){RESET}")
+                results.append({
+                    'command': cmd,
+                    'success': False,
+                    'error': 'Timeout'
+                })
+            except Exception as e:
+                print(f"{RED}✗ Error: {e}{RESET}")
+                results.append({
+                    'command': cmd,
+                    'success': False,
+                    'error': str(e)
+                })
+        
+        return results
+    
+    def process_response(self, response_text, project_dir="."):
+        """
+        Main method: parse response and generate files/run commands
+        Returns True if files were generated, False otherwise
+        """
+        if not self.has_file_instructions(response_text):
+            return False
+        
+        files, commands = self.parse_response(response_text)
+        
+        if not files and not commands:
+            return False
+        
+        created_files = self.create_files(files, base_dir=project_dir)
+        
+        if commands:
+            results = self.run_commands(commands, cwd=project_dir)
+            
+            failed = [r for r in results if not r['success']]
+            if failed:
+                print(f"\n{YELLOW}⚠️  {len(failed)} command(s) failed{RESET}")
+        
+        if created_files:
+            print(f"\n{GREEN}✅ Generated {len(created_files)} file(s) in '{project_dir}/'{RESET}")
+            print(f"{CYAN}📂 Files created:{RESET}")
+            for f in created_files:
+                print(f"   {GREEN}- {f}{RESET}")
+        
+        return True
+    
+    def get_enhanced_prompt(self):
+        """
+        Returns a system prompt addition to teach Gemini how to generate files.
+        Add this to your Gemini system instructions.
+        """
+        return """
+            When the user asks you to create, generate, or build files or a project, respond with file generation instructions using this XML format:
+            <file path="relative/path/to/file.ext">
+            FILE_CONTENT_HERE
+            </file>
+
+            <command>command to run after files are created</command>
+
+            Example:
+            <file path="src/server.js">
+            const express = require('express');
+            const app = express();
+
+            app.get('/hello', (req, res) => {
+            res.json({ message: 'Hello!' });
+            });
+
+            app.listen(3000);
+            </file>
+
+            <file path="package.json">
+            {
+            "name": "my-app",
+            "version": "1.0.0",
+            "dependencies": {
+                "express": "^4.18.0"
+            }
+            }
+            </file>
+
+            <command>npm install</command>
+            <command>npm start</command>
+
+            Rules:
+            - Use relative paths from project root
+            - Include ALL necessary files
+            - Provide complete, working code
+            - Commands run in order after all files are created
+            - You can still provide explanations before or after the XML tags
+            """
+file_generator = LLMFileGenerator()

main.py

@@ -0,0 +1,35 @@
+from display import clear_and_setup, get_colored_prompt
+from builtin_commands import handle_builtin_commands
+from external_commands import run_external_command
+from colors import *
+
+def main():
+    clear_and_setup()
+    
+    while True:
+        try:
+            prompt = get_colored_prompt()
+            line = input(prompt).strip()
+            
+            if not line:
+                continue
+
+            if line.lower() == "exit":
+                print(f"{YELLOW}👋 Goodbye from AcidopShell!{RESET}")
+                break
+            
+            command_parts = line.split()
+            
+            if handle_builtin_commands(command_parts):
+                continue
+            
+            run_external_command(command_parts)
+            
+        except KeyboardInterrupt:
+            print(f"\n{YELLOW}💡 Use 'exit' to quit Codic !{RESET}")
+        except EOFError:
+            print(f"\n{YELLOW}👋 Goodbye from Codic !{RESET}")
+            break
+
+if __name__ == "__main__":
+    main()