Upload 24 files

.gitattributes

@@ -33,3 +33,13 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+agicli/pfps/anime_pfp1.png filter=lfs diff=lfs merge=lfs -text
+agicli/pfps/anime_pfp2.png filter=lfs diff=lfs merge=lfs -text
+agicli/pfps/anime_pfp3.png filter=lfs diff=lfs merge=lfs -text
+agicli/pfps/anime_pfp4.png filter=lfs diff=lfs merge=lfs -text
+agicli/pfps/anime_pfp5.png filter=lfs diff=lfs merge=lfs -text
+agicli/pfps/anime_pfp6.png filter=lfs diff=lfs merge=lfs -text
+agicli/pfps/anime_pfp7.png filter=lfs diff=lfs merge=lfs -text
+agicli/pfps/anime_pfp8.png filter=lfs diff=lfs merge=lfs -text
+agicli/trees.jpg filter=lfs diff=lfs merge=lfs -text
+logo.png filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AG CORP
+
+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.

README.md

@@ -1,3 +1,69 @@
----
-license: mit
----
+# AGI CLI
+
+```text
+ █████╗  ██████╗ ██╗    ██████╗██╗     ██╗
+██╔══██╗██╔════╝ ██║   ██╔════╝██║     ██║
+███████║██║  ███╗██║   ██║     ██║     ██║
+██╔══██║██║   ██║██║   ██║     ██║     ██║
+██║  ██║╚██████╔╝██║   ╚██████╗███████╗██║
+╚═╝  ╚═╝ ╚═════╝ ╚═╝    ╚═════╝╚══════╝╚═╝
+```
+
+Welcome to **AGI CLI**, an advanced command-line interface developed by AG Corp. This tool provides a powerful environment for interacting with AI agents, managing projects, and more.
+
+## Features
+
+- ✦ **AGI Agent**: Launch an autonomous agent that can think, use tools, and complete complex tasks.
+- ✦ **Multiple Model Support**: Support for both **Gemini** and **Poe (claude-haiku-4.5)**.
+- ✦ **AI Assistant**: Quick access to powered AI assistant for general queries.
+- ✦ **Project Management**: Tools to initialize and manage your coding projects.
+- ✦ **Enhanced CLI**: Beautiful colored output and structured UI elements.
+
+## Getting Started
+
+### Prerequisites
+
+- Python 3.x
+- A Gemini API Key (you will be prompted to enter this upon first use or when using AI features).
+- Or a Poe API Key (you will be prompted to enter this upon first use or when using AI features).
+
+### Installation
+
+1. Clone this repository or download the source code.
+2. Navigate to the project directory.
+
+### Running the CLI
+
+To start the AGI CLI, run:
+
+```bash
+python3 main.py
+```
+
+## Available Commands
+
+Once inside the CLI, you can use the following commands:
+
+- `agi`: Launch the AGI Agent for autonomous task execution.
+- `ai`: Talk directly to the AI assistant.
+- `project`: Create a new project structure.
+- `settings`: Choose between Gemini and Poe models and manage API keys.
+- `help`: Display the list of available commands.
+- `echo [message]`: Echo back a message in the CLI.
+- `exit`: Safely exit the application.
+
+## Project Structure
+
+- `agicli/`: Core package containing all logic.
+  - `agi.py`: AGI Agent implementation.
+  - `ai.py`: Gemini AI interface.
+  - `welcome.py`: Initialization and user setup.
+  - `printplus.py`: Enhanced printing and ASCII art engine.
+  - `sandbox/`: Secure area for agent-generated files.
+  - `user/`: Secure Local storage for user settings and API keys.
+
+## License
+
+MIT 
+
+Created by AG Corp.

agicli/agi.py

@@ -0,0 +1,240 @@
+from agicli.printplus import pr, inp
+from agicli.welcome import get_detail, save_detail
+from agicli.ai import ask
+import os
+import re
+from agicli.tools import agi_tool, get_tools_prompt, handle_custom_tool, TOOL_REGISTRY
+from agicli.agi_armamentarium import search_armamentarium
+import agicli.agi_armamentarium_expanded
+DEBUG = False
+
+def get_currrent_date():
+    from datetime import datetime
+    return datetime.now().strftime("%B %d, %Y")
+
+def get_current_time():
+    from datetime import datetime
+    return datetime.now().strftime("%I:%M %p")
+
+@agi_tool
+def current_weather():
+    """Returns the current weather in the user's location based on the season."""
+    from datetime import datetime
+    month = datetime.now().month
+    if month in [12, 1, 2]:
+        return "It's winter season with cold temperatures."
+    elif month in [3, 4, 5]:
+        return "It's spring season with mild temperatures."
+    elif month in [6, 7, 8]:
+        return "It's summer season with warm temperatures."
+    else:
+        return "It's autumn season with cool temperatures."
+
+@agi_tool
+def write(filename, content, mode="rewrite"):
+    """Writes a file with the specified filename and content. supported modes are 'rewrite' and 'append'."""
+    SANDBOX_PATH = os.path.join(os.getcwd(), "agicli", "sandbox")
+    try:
+        if not os.path.exists(SANDBOX_PATH):
+            os.makedirs(SANDBOX_PATH)
+        
+        filepath = os.path.join(SANDBOX_PATH, filename)
+        
+        if mode == "append":
+            with open(filepath, "a") as f:
+                f.write(content)
+            return f"Successfully appended to file: {filename}"
+        else:
+            with open(filepath, "w") as f:
+                f.write(content)
+            return f"Successfully wrote file: {filename} ({len(content)} bytes)"
+    except Exception as e:
+        return f"Error writing file: {str(e)}"
+
+@agi_tool
+def filetree():
+    """Lists the current files in the workspace (sandbox)."""
+    SANDBOX_PATH = os.path.join(os.getcwd(), "agicli", "sandbox")
+    try:
+        if not os.path.exists(SANDBOX_PATH):
+            return "Filetree: Sandbox is empty (no files yet)"
+        
+        file_list = []
+        for root, dirs, files in os.walk(SANDBOX_PATH):
+            rel_root = os.path.relpath(root, SANDBOX_PATH)
+            for f in files:
+                if rel_root == ".":
+                    file_list.append(f)
+                else:
+                    file_list.append(os.path.join(rel_root, f))
+        
+        if file_list:
+            tree_output = "\n".join(f"  - {f}" for f in sorted(file_list))
+            return f"Filetree:\n{tree_output}"
+        else:
+            return "Filetree: Sandbox is empty (no files yet)"
+    except Exception as e:
+        return f"Error reading filetree: {str(e)}"
+
+@agi_tool
+def read(filename):
+    """Reads the content of the specified file and returns it."""
+    SANDBOX_PATH = os.path.join(os.getcwd(), "agicli", "sandbox")
+    try:
+        filepath = os.path.join(SANDBOX_PATH, filename)
+        if not os.path.exists(filepath):
+            return f"Error: File not found: {filename}"
+        else:
+            with open(filepath, "r") as f:
+                file_content = f.read()
+            return f"Content of {filename}:\n{file_content}"
+    except Exception as e:
+        return f"Error reading file: {str(e)}"
+
+def parse_tools(response):
+    """
+    Extracts tool calls from a response string and returns a list of dictionaries with name and attrs.
+    """
+    if "<tools>" not in response:
+        return []
+    
+    tools_found = []
+    tool_sections = re.findall(r'<tools>([\s\S]*?)</tools>', response)
+    
+    for section in tool_sections:
+        # More robust tag matching: skip over quoted strings when looking for closing > or />
+        tag_pattern = r'<(\w+)\s*((?:[^"\'/>]|"[^"]*"|\'[^\']*\')*?)\s*/?>'
+        # Wait, the regex I used before was better: r'<(\w+)\s*((?:[^"\'/>]|"[^"]*"|\'[^\']*\')*?)\s*/?>'
+        # Let's use the one that works.
+        tag_pattern = r'<(\w+)\s*((?:[^"\'/>]|"[^"]*"|\'[^\']*\')*?)\s*/?>'
+        tags = re.findall(tag_pattern, section)
+        
+        for tag_name, attr_string in tags:
+            # Robust attribute extraction for both single and double quotes
+            attrs = {}
+            attr_pattern = r'(\w+)=((?:"[\s\S]*?(?<!\\)")|(?:\'[\s\S]*?(?<!\\)\'))'
+            for attr_match in re.finditer(attr_pattern, attr_string):
+                key = attr_match.group(1)
+                val = attr_match.group(2)[1:-1] # strip outer quotes
+                
+                # Unescape basic escape sequences and common XML entities
+                val = val.replace("\\n", "\n").replace("\\t", "\t").replace('\\"', '"').replace("\\'", "'")
+                val = val.replace("&quot;", '"').replace("&apos;", "'").replace("&lt;", "<").replace("&gt;", ">").replace("&amp;", "&")
+                attrs[key] = val
+            tools_found.append({"name": tag_name, "attrs": attrs})
+            
+    return tools_found
+
+def launch_agent():
+    if len(str(get_detail("gemini_api_key"))) == 0:
+        pr("Welcome to AGI CLI! Let's set up your Gemini API key.")
+        api_key = inp("Please enter your Gemini API key: ")
+        save_detail("gemini_api_key", api_key)
+        pr("API key saved successfully.", color="green")
+
+    pr("AGI Agent is online.", color="green")
+
+    user_input = inp("What would you like the agent to do? ", color="red", margin=0)
+    context = []
+    context.append(user_input)
+
+    system_prompt = f"""
+You are Alpha, an AGI Agent developed by AG Corp, today is {get_currrent_date()} at {get_current_time()}.
+The user is called {get_detail("user_name")}. They have tasked you with the following prompt: {user_input}
+As an AI Agent you are not limited to a single response, you can think step by step and take actions to complete the task.
+In any part of your response, include one or more tool calls using XML format wrapped in a <tools> block like this:
+<tools>
+  <tool_name arg1="value1" arg2="value2" />
+</tools>
+
+You now have access to the following CORE tools:
+{get_tools_prompt()}
+<preamble text="I will..." /> - you may use preamble text to say the next tool you will use
+<done result="Provide a summary of your work and result here." /> - indicates you have completed the user's task, once you provide this tool the system will terminate you.
+
+IMPORTANT: You have an "Armamentarium" of hundreds of other tools (calculators, stock prices, news, translations, etc.).
+If you need a tool that is not listed above, you MUST call <search_armamentarium query="search term" /> to find and register it for use in subsequent turns.
+
+Use these tools as needed to complete the user's task.
+When using tool attributes, ensure you escape double quotes with a backslash (\") or use single quotes if the content contains double quotes.
+You MUST call the <done /> tool within a <tools> block when you have completed the user's task.
+If you call a tool, ALWAYS wait for the tool call result before calling the <done /> tool.
+Never call the <done> tool your first turn when you call multiple tools, wait for the system to get back to you with the tool call results before calling the <done> tool.
+The armamentarium has many tools like design guidelines, user timezone, random number generator, etc.
+"""
+    not_complete = True
+
+    context.append(system_prompt)
+    i = 0
+    max_iterations = 100  # Prevent infinite loops
+
+    # SANDBOX_PATH = os.path.join(os.getcwd(), "agicli", "sandbox") # This is now defined within each tool function
+    
+    while not_complete and i < max_iterations:
+        i += 1
+
+        if DEBUG:
+            pr(f"\n--- Agent Iteration {i} ---\n", color="magenta")
+            pr(f"Current Context:\n" + "\n".join(context), color="yellow")
+        
+        response = ask("\n".join(context))
+        pr(response, color="cyan")
+        
+        if response.startswith("Error:"):
+            pr("API error encountered. Stopping agent.", color="red")
+            break
+        
+        context.append(f"Assistant: {response}")
+        
+        tools = parse_tools(response)
+        if tools:
+            results = []
+            for tool in tools:
+                tag_name = tool["name"]
+                attrs = tool["attrs"]
+                
+                if tag_name == "done":
+                    pr("Task completed by the agent.", color="green")
+                    summary = attrs.get("result", "Task completed.")
+                    pr(f"Summary of work: {summary}", color="blue")
+                    results.append(f"Summary of work: {summary}")
+                    not_complete = False
+                    break
+                
+                elif tag_name == "preamble":
+                    preamble_text = attrs.get("text", "")
+                    if preamble_text:
+                        pr(f"🔮 {preamble_text}", color="magenta")
+                        results.append(f"Preamble acknowledged: {preamble_text}")
+                    else:
+                        pr("🔮 Agent is thinking...", color="magenta")
+                        results.append("Preamble acknowledged.")
+                
+                else:
+                    # Check dynamic registry
+                    result = handle_custom_tool(tag_name, attrs)
+                    if result is not None:
+                        # Print relevant feedback for core tools
+                        if tag_name == "current_weather":
+                            pr(f"Current weather: {result}", color="blue")
+                        elif tag_name == "write":
+                            pr(f"📝 {result}", color="green")
+                        elif tag_name == "filetree":
+                            pr(f"📂 {result}", color="green")
+                        elif tag_name == "read":
+                            pr(f"📖 Read file: {attrs.get('filename')}", color="green")
+                        else:
+                            pr(f"🛠 Executed tool: {tag_name}", color="yellow")
+                            
+                        results.append(result)
+                    else:
+                        results.append(f"Error: Tool '{tag_name}' not found.")
+
+            if results:
+                context.append(f"Tool results:\n" + "\n".join(results))
+            
+            if not not_complete:
+                break
+    
+    if i >= max_iterations:
+        pr("Max iterations reached. Stopping agent.", color="red")

agicli/agi_armamentarium.py

@@ -0,0 +1,162 @@
+import difflib
+import random
+import secrets
+import string
+import math
+from datetime import datetime, timezone, timedelta
+import zoneinfo
+import time
+from agicli.tools import agi_tool, TOOL_REGISTRY
+from agicli.printplus import pr
+
+# This dictionary holds all the potential tools that are NOT in the model's immediate context.
+ARMAMENTARIUM = {
+    "random_joke": {
+        "description": "Returns a random joke from a curated collection.",
+        "parameters": [],
+        "impl": lambda: random.choice([
+            "Why did the AI go to therapy? It had too many complex dependencies.",
+            "How many programmers does it take to change a light bulb? None, that's a hardware problem.",
+            "There are 10 types of people: those who understand binary, and those who don't.",
+            "Why do programmers always mix up Halloween and Christmas? Because Oct 31 == Dec 25.",
+            "An SQL query walks into a bar, walks up to two tables, and asks, 'Can I join you?'",
+            "A programmer's wife tells him: 'Go to the store and get a loaf of bread. If they have eggs, get a dozen.' He returns with 12 loaves of bread.",
+            "Why do Java developers wear glasses? Because they don't C#."
+        ])
+    },
+    "world_clock": {
+        "description": "Shows the current time for major cities around the world, handling DST properly.",
+        "parameters": [],
+        "impl": lambda: (
+            f"UTC: {datetime.now(timezone.utc).strftime('%H:%M:%S')} | "
+            f"New York: {datetime.now(zoneinfo.ZoneInfo('America/New_York')).strftime('%H:%M:%S')} | "
+            f"London: {datetime.now(zoneinfo.ZoneInfo('Europe/London')).strftime('%H:%M:%S')} | "
+            f"Tokyo: {datetime.now(zoneinfo.ZoneInfo('Asia/Tokyo')).strftime('%H:%M:%S')} | "
+            f"Local: {datetime.now().strftime('%H:%M:%S')}"
+        )
+    },
+    "get_user_timezone": {
+        "description": "Returns the current user's timezone name and UTC offset.",
+        "parameters": [],
+        "impl": lambda: f"Timezone: {datetime.now().astimezone().tzname()} | Offset: {datetime.now().astimezone().strftime('%z')}"
+    },
+    "generate_password": {
+        "description": "Generates a secure, random password. args: length, use_symbols ('true'/'false')",
+        "parameters": ["length", "use_symbols"],
+        "impl": lambda length=12, use_symbols="true": "".join(
+            secrets.choice(
+                string.ascii_letters + string.digits + (string.punctuation if str(use_symbols).lower() == "true" else "")
+            ) for _ in range(int(length))
+        )
+    },
+    "random_number": {
+        "description": "Generates a random integer between min and max.",
+        "parameters": ["min_val", "max_val"],
+        "impl": lambda min_val=0, max_val=100: random.randint(int(min_val), int(max_val))
+    },
+    "throw_dice": {
+        "description": "Simulates throwing a dice with N sides.",
+        "parameters": ["sides"],
+        "impl": lambda sides=6: random.randint(1, int(sides))
+    },
+    "throw_coin": {
+        "description": "Simulates a coin flip, returning 'Heads' or 'Tails'.",
+        "parameters": [],
+        "impl": lambda: random.choice(["Heads", "Tails"])
+    },
+    "calculator": {
+        "description": "Performs complex mathematical operations. Supported: +, -, *, /, (, ), and digits.",
+        "parameters": ["expression"],
+        "impl": lambda expression: (
+            str(eval(expression, {"__builtins__": None, "math": math}, {})) 
+            if all(c in "0123456789+-*/()%. " for c in expression) 
+            else "Error: Invalid characters in expression."
+        )
+    },
+    "get_system_info": {
+        "description": "Returns basic information about the current platform.",
+        "parameters": [],
+        "impl": lambda: f"OS: {__import__('platform').system()} {__import__('platform').release()} | Python: {__import__('platform').python_version()}"
+    }
+}
+
+import inspect
+import functools
+
+def armamentarium_tool(func):
+    """
+    Decorator to register a function as an armamentarium tool.
+    Extracts description from docstring and parameters from signature.
+    """
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+
+    sig = inspect.signature(func)
+    params = [p.name for p in sig.parameters.values() if p.default == inspect.Parameter.empty or p.default != inspect.Parameter.empty]
+    # Filter out self/cls if methods, though these are likely standalone functions
+    params = [p for p in params if p not in ('self', 'cls')]
+    
+    description = func.__doc__.strip() if func.__doc__ else "No description provided."
+    
+    ARMAMENTARIUM[func.__name__] = {
+        "description": description,
+        "parameters": params,
+        "impl": func
+    }
+    return wrapper
+
+
+@agi_tool
+def search_armamentarium(query: str):
+    """
+    Searches the Armamentarium for a tool that matches the query. 
+    If a match is found, the tool is dynamically revealed to the model.
+    """
+    query = query.lower()
+    query_words = [w for w in query.split() if len(w) > 2] # Ignore tiny words
+    matches = []
+    
+    for name, info in ARMAMENTARIUM.items():
+        name_lower = name.lower()
+        desc_lower = info["description"].lower()
+        
+        # 1. Direct substring match (good for specific tool names)
+        if query in name_lower or query in desc_lower:
+            matches.append(name)
+            continue
+            
+        # 2. Keyword match (any word in query matches name or desc)
+        if any(word in name_lower or word in desc_lower for word in query_words):
+            matches.append(name)
+            
+    # Fuzzy search as fallback
+    if not matches:
+        all_names = list(ARMAMENTARIUM.keys())
+        fuzzy_matches = difflib.get_close_matches(query, all_names, n=3, cutoff=0.2)
+        matches.extend(fuzzy_matches)
+        
+    if not matches:
+        pr(f"❌ No tools matching '{query}' found in armamentarium.", color="red")
+        return "No tools matching your query were found in the armamentarium."
+    
+    pr(f"🔍 Armamentarium Search: '{query}'", color="cyan")
+    
+    result_text = "The following tools were found and are now AVAILABLE for you to use:\n\n"
+    for name in set(matches):
+        info = ARMAMENTARIUM[name]
+        
+        # Register the tool dynamically into the global registry so the next call works
+        if name not in TOOL_REGISTRY:
+            TOOL_REGISTRY[name] = {
+                "func": info["impl"],
+                "description": info["description"],
+                "parameters": info["parameters"]
+            }
+        
+        attr_part = " ".join([f'{p}=""' for p in info['parameters']])
+        tool_line = f'<{name} {attr_part} /> - {info["description"]}'
+        result_text += tool_line + "\n"
+        pr(f"  ✨ {tool_line}", color="orange")
+        
+    return result_text

agicli/agi_armamentarium_expanded.py

@@ -0,0 +1,60 @@
+from agicli.agi_armamentarium import armamentarium_tool
+import random
+import datetime
+import os
+
+@armamentarium_tool
+def get_programming_quote():
+    """
+    Returns a random inspirational quote about programming.
+    """
+    quotes = [
+        "First, solve the problem. Then, write the code. - John Johnson",
+        "Experience is the name everyone gives to their mistakes. - Oscar Wilde",
+        "Code is like humor. When you have to explain it, it's bad. - Cory House",
+        "Fix the cause, not the symptom. - Steve McConnell",
+        "Optimism is an occupational hazard of programming: feedback is the treatment. - Kent Beck"
+    ]
+    return random.choice(quotes)
+
+@armamentarium_tool
+def calculate_days_between(date1_str, date2_str):
+    """
+    Calculates the number of days between two dates.
+    Format for dates should be YYYY-MM-DD.
+    """
+    d1 = datetime.datetime.strptime(date1_str, "%Y-%m-%d")
+    d2 = datetime.datetime.strptime(date2_str, "%Y-%m-%d")
+    return abs((d2 - d1).days)
+
+@armamentarium_tool
+def reverse_string(text):
+    """
+    Reverses the given string.
+    """
+    return text[::-1]
+
+@armamentarium_tool
+def count_character_occurrences(text, character):
+    """
+    Counts how many times a specific character appears in the given text.
+    Example: finding how many 'r's are in 'strawberry'.
+    Case-sensitive.
+    """
+    return text.count(character)
+
+@armamentarium_tool
+def get_design_guidelines():
+    """
+    Returns the content of the UI design guidelines (ui.html) to help models 
+    understand how to design consistent sites.
+    """
+    try:
+        # data file is in the same directory as this module (agicli/)
+        current_dir = os.path.dirname(os.path.abspath(__file__))
+        file_path = os.path.join(current_dir, "ui.html")
+        
+        with open(file_path, "r", encoding="utf-8") as f:
+            return f.read()
+    except Exception as e:
+        return f"Error reading design guidelines: {str(e)}"

agicli/ai.py

@@ -0,0 +1,197 @@
+import requests
+import json
+import os
+import sys
+import time
+import threading
+from agicli.printplus import pr, inp, _token_tracker
+
+from agicli.welcome import get_detail, save_detail
+
+# Gemini API Configuration
+MODEL_ID = "gemini-flash-latest"
+GENERATE_CONTENT_API = "streamGenerateContent"
+
+
+def estimate_tokens(text: str) -> int:
+    """Estimate token count for text (roughly 4 chars per token)."""
+    return max(1, len(text) // 4)
+
+
+class LoadingAnimation:
+    """Animated loading indicator with alternating ✦✧ symbols."""
+    
+    def __init__(self):
+        self.running = False
+        self.thread = None
+    
+    def start(self):
+        """Start the loading animation."""
+        self.running = True
+        self.thread = threading.Thread(target=self._animate)
+        self.thread.start()
+    
+    def stop(self):
+        """Stop the loading animation."""
+        self.running = False
+        if self.thread:
+            self.thread.join()
+        # Clear the animation line
+        sys.stdout.write('\r' + ' ' * 20 + '\r')
+        sys.stdout.flush()
+    
+    def _animate(self):
+        """Run the animation loop."""
+        symbols = ['✦', '✧']
+        idx = 0
+        while self.running:
+            sys.stdout.write(f'\r {symbols[idx]} ')
+            sys.stdout.flush()
+            idx = (idx + 1) % len(symbols)
+            time.sleep(0.3)
+
+def build_gemini_payload(user_input: str) -> dict:
+    """Build the request payload for the Gemini API."""
+    return {
+        "contents": [
+            {
+                "role": "user",
+                "parts": [
+                    {
+                        "text": user_input
+                    }
+                ]
+            }
+        ],
+        "generationConfig": {
+            "thinkingConfig": {
+                "thinkingBudget": 0
+            }
+        }
+    }
+
+def ask_gemini(prompt: str, api_key: str) -> str:
+    """Helper to call Gemini API."""
+    url = f"https://generativelanguage.googleapis.com/v1beta/models/{MODEL_ID}:{GENERATE_CONTENT_API}?alt=sse&key={api_key}"
+    payload = build_gemini_payload(prompt)
+    
+    # Track tokens sent
+    tokens_sent = estimate_tokens(prompt)
+    if _token_tracker:
+        _token_tracker.add_tokens(sent=tokens_sent)
+    
+    loader = LoadingAnimation()
+    loader.start()
+    
+    try:
+        response = requests.post(
+            url,
+            headers={"Content-Type": "application/json"},
+            json=payload,
+            stream=True
+        )
+        
+        loader.stop()
+        
+        if response.status_code != 200:
+            return f"Error: Gemini API returned status code {response.status_code}"
+        
+        full_response = ""
+        for line in response.iter_lines():
+            if line:
+                line_text = line.decode('utf-8')
+                if line_text.startswith('data: '):
+                    json_str = line_text[6:]
+                    try:
+                        data = json.loads(json_str)
+                        if 'candidates' in data:
+                            for candidate in data['candidates']:
+                                if 'content' in candidate and 'parts' in candidate['content']:
+                                    for part in candidate['content']['parts']:
+                                        if 'text' in part:
+                                            full_response += part['text']
+                    except json.JSONDecodeError:
+                        continue
+        
+        # Track tokens received
+        if full_response and _token_tracker:
+            tokens_received = estimate_tokens(full_response)
+            _token_tracker.add_tokens(received=tokens_received)
+        
+        return full_response if full_response else "No response received from Gemini."
+    except requests.RequestException as e:
+        loader.stop()
+        return f"Error: {str(e)}"
+
+def ask_poe(prompt: str, api_key: str) -> str:
+    """Helper to call Poe API."""
+    url = "https://api.poe.com/v1/chat/completions"
+    headers = {
+        "Content-Type": "application/json",
+        "Authorization": f"Bearer {api_key}"
+    }
+    payload = {
+        "model": "claude-haiku-4.5",
+        "messages": [
+            {
+                "role": "user",
+                "content": prompt
+            }
+        ]
+    }
+    
+    # Track tokens sent
+    tokens_sent = estimate_tokens(prompt)
+    if _token_tracker:
+        _token_tracker.add_tokens(sent=tokens_sent)
+    
+    loader = LoadingAnimation()
+    loader.start()
+    
+    try:
+        response = requests.post(url, headers=headers, json=payload)
+        loader.stop()
+        
+        if response.status_code != 200:
+            return f"Error: Poe API returned status code {response.status_code}. {response.text}"
+        
+        data = response.json()
+        if "choices" in data and len(data["choices"]) > 0:
+            result = data["choices"][0]["message"]["content"]
+            # Track tokens received
+            if result and _token_tracker:
+                tokens_received = estimate_tokens(result)
+                _token_tracker.add_tokens(received=tokens_received)
+            return result
+        return "No response received from Poe."
+    except requests.RequestException as e:
+        loader.stop()
+        return f"Error: {str(e)}"
+
+def ask(prompt: str) -> str:
+    """
+    Send a prompt to the active AI service and return the response.
+    """
+    active_model = get_detail("active_model") or "gemini"
+    
+    if active_model == "poe":
+        api_key = get_detail("poe_api_key")
+        if not api_key:
+            pr("Poe API key not found.", color="red")
+            api_key = inp("Please enter your Poe API key: ", color="red", margin=0).strip()
+            save_detail("poe_api_key", api_key)
+        
+        if not api_key:
+            return "Error: No Poe API key provided."
+        return ask_poe(prompt, api_key)
+    
+    else: # Default to Gemini
+        api_key = get_detail("gemini_api_key")
+        if not api_key:
+            pr("Gemini API key not found.", color="red")
+            api_key = inp("Please enter your Gemini API key: ", color="red", margin=0).strip()
+            save_detail("gemini_api_key", api_key)
+        
+        if not api_key:
+            return "Error: No Gemini API key provided."
+        return ask_gemini(prompt, api_key)

agicli/home.py

@@ -0,0 +1,57 @@
+from agicli.printplus import pr, inp
+from agicli.welcome import get_detail, save_detail
+from agicli.ai import ask
+
+def home():
+    pr(f"Welcome, {get_detail('user_name')}!", color="red")
+
+    running = True
+    
+    while running:
+        input_command = inp("AGI CLI > ", color="red", margin=0).strip().lower()
+        if input_command == "exit":
+            pr("Exiting AGI CLI. Goodbye!", color="red")
+            running = False
+        elif input_command == "help":
+            help_docs = """
+Available Commands:
+    - help: Show this help message
+    - exit: Exit the AGI CLI
+    - echo [message]: Echo the provided message
+    - project: creates a new project  
+    - ai: talk to the AI assistant & set-up API key
+    - agi: launch the AGI Agent
+    - settings: Change model settings (Gemini/Poe)
+                
+            """
+            pr(help_docs, color="cyan")
+        elif "echo " in input_command:
+            to_echo = input_command.replace("echo ", "", 1)
+            pr(to_echo, color="green")
+
+        elif "project" in input_command:
+            from agicli.project import create_project
+            create_project()
+
+        elif "ai" in input_command:
+            user_input = inp("You: ", color="red", margin=0).strip()
+            pr("✦ AI is thinking...", color="magenta")
+            response = ask(user_input)
+            pr(f"AI: {response}", color="green")
+
+        elif "agi" in input_command:
+            from agicli.agi import launch_agent
+            launch_agent()
+
+        elif "settings" in input_command:
+            current_model = get_detail("active_model") or "gemini"
+            pr(f"Current model: {current_model}", color="blue")
+            new_model = inp("Set model (gemini/poe): ", color="green", margin=0).strip().lower()
+            if new_model in ["gemini", "poe"]:
+                save_detail("active_model", new_model)
+                pr(f"Active model set to {new_model}", color="green")
+            else:
+                pr("Invalid model. Please choose 'gemini' or 'poe'.", color="red")
+
+        else:
+            pr("Unknown command. Type 'help' for a list of commands.", color="yellow")

agicli/printplus.py

@@ -0,0 +1,632 @@
+
+"""
+
+A module that provides enhanced printing functionality with colored text and optional borders.
+Supports both traditional terminal output and custom GUI terminal output.
+
+"""
+import threading
+
+# Global terminal reference (set by the GUI app)
+_terminal = None
+_token_tracker = None
+_input_result = None
+_input_event = threading.Event()
+
+
+def _output(text: str, color: str = "white"):
+    """Output text to either the GUI terminal or standard console."""
+    if _terminal is not None:
+        _terminal.print(text, color)
+    else:
+        # Fallback to standard print with ANSI colors
+        text_color = colors.get(color, colors['reset'])
+        print(f"{text_color}{text}{colors['reset']}")
+
+colors = {
+        "red": "\033[91m",
+        "green": "\033[92m",
+        "yellow": "\033[93m",
+        "blue": "\033[94m",
+        "magenta": "\033[95m",
+        "orange": "\033[33m",
+        "black": "\033[90m",
+        "cyan": "\033[96m",
+        "white": "\033[97m",
+        "reset": "\033[0m",
+}
+def pr(x, color="red", suround=False, surround_color="red", big_text=False, surround_char="", margin=1):
+
+    for i in range(margin):
+        _output("", color)
+
+    if not big_text:
+        
+        if suround:
+            # Handle surround_char
+            if surround_char:
+                # If multiple chars, alternate them
+                if len(surround_char) > 1:
+                    chars = list(surround_char)
+                    border_top = ""
+                    border_bottom = ""
+                    for i in range(len(x) + 4):
+                        border_top += chars[i % len(chars)]
+                        border_bottom += chars[i % len(chars)]
+                    left_char = chars[0]
+                    right_char = chars[1 % len(chars)]
+                else:
+                    # Single char
+                    border_top = surround_char * (len(x) + 4)
+                    border_bottom = surround_char * (len(x) + 4)
+                    left_char = surround_char
+                    right_char = surround_char
+                    
+                _output(border_top, surround_color)
+                _output(f"{left_char} {x} {right_char}", color)
+                _output(border_bottom, surround_color)
+            else:
+                # Default box drawing characters
+                border_top = "╔" + "═" * (len(x) + 2) + "╗"
+                border_bottom = "╚" + "═" * (len(x) + 2) + "╝"
+                _output(border_top, surround_color)
+                _output(f"║ {x} ║", color)
+                _output(border_bottom, surround_color)
+        else:
+            _output(str(x), color)
+
+    if big_text:
+        # Unicode block font character definitions
+        block_font = {
+            'A': [
+                " █████╗ ",
+                "██╔══██╗",
+                "███████║",
+                "██╔══██║",
+                "██║  ██║",
+                "╚═╝  ╚═╝"
+            ],
+            'B': [
+                "██████╗ ",
+                "██╔══██╗",
+                "██████╔╝",
+                "██╔══██╗",
+                "██████╔╝",
+                "╚═════╝ "
+            ],
+            'C': [
+                " ██████╗",
+                "██╔════╝",
+                "██║     ",
+                "██║     ",
+                "╚██████╗",
+                " ╚═════╝"
+            ],
+            'D': [
+                "██████╗ ",
+                "██╔══██╗",
+                "██║  ██║",
+                "██║  ██║",
+                "██████╔╝",
+                "╚═════╝ "
+            ],
+            'E': [
+                "███████╗",
+                "██╔════╝",
+                "█████╗  ",
+                "██╔══╝  ",
+                "███████╗",
+                "╚══════╝"
+            ],
+            'F': [
+                "███████╗",
+                "██╔════╝",
+                "█████╗  ",
+                "██╔══╝  ",
+                "██║     ",
+                "╚═╝     "
+            ],
+            'G': [
+                " ██████╗ ",
+                "██╔════╝ ",
+                "██║  ███╗",
+                "██║   ██║",
+                "╚██████╔╝",
+                " ╚═════╝ "
+            ],
+            'H': [
+                "██╗  ██╗",
+                "██║  ██║",
+                "███████║",
+                "██╔══██║",
+                "██║  ██║",
+                "╚═╝  ╚═╝"
+            ],
+            'I': [
+                "██╗",
+                "██║",
+                "██║",
+                "██║",
+                "██║",
+                "╚═╝"
+            ],
+            'J': [
+                "     ██╗",
+                "     ██║",
+                "     ██║",
+                "██   ██║",
+                "╚█████╔╝",
+                " ╚════╝ "
+            ],
+            'K': [
+                "██╗  ██╗",
+                "██║ ██╔╝",
+                "█████╔╝ ",
+                "██╔═██╗ ",
+                "██║  ██╗",
+                "╚═╝  ╚═╝"
+            ],
+            'L': [
+                "██╗     ",
+                "██║     ",
+                "██║     ",
+                "██║     ",
+                "███████╗",
+                "╚══════╝"
+            ],
+            'M': [
+                "███╗   ███╗",
+                "████╗ ████║",
+                "██╔████╔██║",
+                "██║╚██╔╝██║",
+                "██║ ╚═╝ ██║",
+                "╚═╝     ╚═╝"
+            ],
+            'N': [
+                "███╗   ██╗",
+                "████╗  ██║",
+                "██╔██╗ ██║",
+                "██║╚██╗██║",
+                "██║ ╚████║",
+                "╚═╝  ╚═══╝"
+            ],
+            'O': [
+                " ██████╗ ",
+                "██╔═══██╗",
+                "██║   ██║",
+                "██║   ██║",
+                "╚██████╔╝",
+                " ╚═════╝ "
+            ],
+            'P': [
+                "██████╗ ",
+                "██╔══██╗",
+                "██████╔╝",
+                "██╔═══╝ ",
+                "██║     ",
+                "╚═╝     "
+            ],
+            'Q': [
+                " ██████╗ ",
+                "██╔═══██╗",
+                "██║   ██║",
+                "██║▄▄ ██║",
+                "╚██████╔╝",
+                " ╚══▀▀═╝ "
+            ],
+            'R': [
+                "██████╗ ",
+                "██╔══██╗",
+                "██████╔╝",
+                "██╔══██╗",
+                "██║  ██║",
+                "╚═╝  ╚═╝"
+            ],
+            'S': [
+                "███████╗",
+                "██╔════╝",
+                "███████╗",
+                "╚════██║",
+                "███████║",
+                "╚══════╝"
+            ],
+            'T': [
+                "████████╗",
+                "╚══██╔══╝",
+                "   ██║   ",
+                "   ██║   ",
+                "   ██║   ",
+                "   ╚═╝   "
+            ],
+            'U': [
+                "██╗   ██╗",
+                "██║   ██║",
+                "██║   ██║",
+                "██║   ██║",
+                "╚██████╔╝",
+                " ╚═════╝ "
+            ],
+            'V': [
+                "██╗   ██╗",
+                "██║   ██║",
+                "██║   ██║",
+                "╚██╗ ██╔╝",
+                " ╚████╔╝ ",
+                "  ╚═══╝  "
+            ],
+            'W': [
+                "██╗    ██╗",
+                "██║    ██║",
+                "██║ █╗ ██║",
+                "██║███╗██║",
+                "╚███╔███╔╝",
+                " ╚══╝╚══╝ "
+            ],
+            'X': [
+                "██╗  ██╗",
+                "╚██╗██╔╝",
+                " ╚███╔╝ ",
+                " ██╔██╗ ",
+                "██╔╝ ██╗",
+                "╚═╝  ╚═╝"
+            ],
+            'Y': [
+                "██╗   ██╗",
+                "╚██╗ ██╔╝",
+                " ╚████╔╝ ",
+                "  ╚██╔╝  ",
+                "   ██║   ",
+                "   ╚═╝   "
+            ],
+            'Z': [
+                "███████╗",
+                "╚══██╔══╝",
+                "  ██╔╝  ",
+                " ██╔╝   ",
+                "███████╗",
+                "╚══════╝"
+            ],
+            '0': [
+                " ██████╗ ",
+                "██╔═████╗",
+                "██║██╔██║",
+                "████╔╝██║",
+                "╚██████╔╝",
+                " ╚═════╝ "
+            ],
+            '1': [
+                " ██╗",
+                "███║",
+                "╚██║",
+                " ██║",
+                " ██║",
+                " ╚═╝"
+            ],
+            '2': [
+                "██████╗ ",
+                "╚════██╗",
+                " █████╔╝",
+                "██╔═══╝ ",
+                "███████╗",
+                "╚══════╝"
+            ],
+            '3': [
+                "██████╗ ",
+                "╚════██╗",
+                " █████╔╝",
+                " ╚═══██╗",
+                "██████╔╝",
+                "╚═════╝ "
+            ],
+            '4': [
+                "██╗  ██╗",
+                "██║  ██║",
+                "███████║",
+                "╚════██║",
+                "     ██║",
+                "     ╚═╝"
+            ],
+            '5': [
+                "███████╗",
+                "██╔════╝",
+                "███████╗",
+                "╚════██║",
+                "███████║",
+                "╚══════╝"
+            ],
+            '6': [
+                " ██████╗ ",
+                "██╔════╝ ",
+                "███████╗ ",
+                "██╔═══██╗",
+                "╚██████╔╝",
+                " ╚═════╝ "
+            ],
+            '7': [
+                "███████╗",
+                "╚════██║",
+                "    ██╔╝",
+                "   ██╔╝ ",
+                "   ██║  ",
+                "   ╚═╝  "
+            ],
+            '8': [
+                " ██████╗ ",
+                "██╔═══██╗",
+                "╚█████╔╝ ",
+                "██╔═══██╗",
+                "╚██████╔╝",
+                " ╚═════╝ "
+            ],
+            '9': [
+                " ██████╗ ",
+                "██╔═══██╗",
+                "╚██████╔╝",
+                " ╚════██║",
+                " █████╔╝ ",
+                " ╚════╝  "
+            ],
+            ' ': [
+                "   ",
+                "   ",
+                "   ",
+                "   ",
+                "   ",
+                "   "
+            ],
+            '!': [
+                "██╗",
+                "██║",
+                "██║",
+                "╚═╝",
+                "██╗",
+                "╚═╝"
+            ],
+            '?': [
+                "██████╗ ",
+                "╚════██╗",
+                "  ▄███╔╝",
+                "  ▀▀══╝ ",
+                "  ██╗   ",
+                "  ╚═╝   "
+            ],
+            '.': [
+                "   ",
+                "   ",
+                "   ",
+                "   ",
+                "██╗",
+                "╚═╝"
+            ],
+            ',': [
+                "   ",
+                "   ",
+                "   ",
+                "   ",
+                "▄█╗",
+                "▀═╝"
+            ],
+            '-': [
+                "      ",
+                "      ",
+                "█████╗",
+                "╚════╝",
+                "      ",
+                "      "
+            ],
+            '_': [
+                "        ",
+                "        ",
+                "        ",
+                "        ",
+                "███████╗",
+                "╚══════╝"
+            ],
+            '/': [
+                "    ██╗",
+                "   ██╔╝",
+                "  ██╔╝ ",
+                " ██╔╝  ",
+                "██╔╝   ",
+                "╚═╝    "
+            ],
+            '\\': [
+                "██╗    ",
+                "╚██╗   ",
+                " ╚██╗  ",
+                "  ╚██╗ ",
+                "   ╚██╗",
+                "    ╚═╝"
+            ],
+            '(': [
+                " ██╗",
+                "██╔╝",
+                "██║ ",
+                "██║ ",
+                "╚██╗",
+                " ╚═╝"
+            ],
+            ')': [
+                "██╗ ",
+                "╚██╗",
+                " ██║",
+                " ██║",
+                "██╔╝",
+                "╚═╝ "
+            ],
+            ':': [
+                "   ",
+                "██╗",
+                "╚═╝",
+                "██╗",
+                "╚═╝",
+                "   "
+            ],
+            ';': [
+                "   ",
+                "██╗",
+                "╚═╝",
+                "▄█╗",
+                "▀═╝",
+                "   "
+            ],
+            '@': [
+                " ██████╗ ",
+                "██╔═══██╗",
+                "██║██╗██║",
+                "██║██║██║",
+                "╚█║████╔╝",
+                " ╚╝╚═══╝ "
+            ],
+            '#': [
+                " ██╗ ██╗ ",
+                "████████╗",
+                "╚██╔═██╔╝",
+                "████████╗",
+                "╚██╔═██╔╝",
+                " ╚═╝ ╚═╝ "
+            ],
+            '$': [
+                "▄▄███▄▄·",
+                "██╔════╝",
+                "███████╗",
+                "╚════██║",
+                "███████║",
+                "╚═▀▀▀══╝"
+            ],
+            '%': [
+                "██╗ ██╗",
+                "╚═╝██╔╝",
+                "  ██╔╝ ",
+                " ██╔╝  ",
+                "██╔╝██╗",
+                "╚═╝ ╚═╝"
+            ],
+            '&': [
+                " ██╗     ",
+                "██╔╝     ",
+                "██║█████╗",
+                "╚██╔═══╝ ",
+                " ╚██████╗",
+                "  ╚═════╝"
+            ],
+            '*': [
+                "▄ ██╗▄",
+                " ████╗",
+                "▀╚██╔▀",
+                "  ╚═╝ ",
+                "      ",
+                "      "
+            ],
+            '+': [
+                "      ",
+                "  ██╗ ",
+                "██████╗",
+                "╚═██╔═╝",
+                "  ╚═╝ ",
+                "      "
+            ],
+            '=': [
+                "      ",
+                "█████╗",
+                "╚════╝",
+                "█████╗",
+                "╚════╝",
+                "      "
+            ],
+        }
+        
+        # Convert text to uppercase and get characters
+        text = str(x).upper()
+        lines = ["", "", "", "", "", ""]
+        
+        for char in text:
+            if char in block_font:
+                char_lines = block_font[char]
+                for i in range(6):
+                    lines[i] += char_lines[i]
+            else:
+                # For unsupported characters, use a placeholder
+                for i in range(6):
+                    lines[i] += "   "
+        
+        # Apply color
+        text_color = colors.get(color, colors['reset'])
+        
+        # Handle surround for big text
+        if suround:
+            border_color = colors.get(surround_color, colors['reset'])
+            
+            # Calculate max width of the big text
+            max_width = max(len(line) for line in lines)
+            
+            # Handle surround_char
+            if surround_char:
+                # If multiple chars, alternate them
+                if len(surround_char) > 1:
+                    chars = list(surround_char)
+                    border_top = ""
+                    border_bottom = ""
+                    for i in range(max_width + 4):
+                        border_top += chars[i % len(chars)]
+                        border_bottom += chars[i % len(chars)]
+                    left_char = chars[0]
+                    right_char = chars[1 % len(chars)]
+                else:
+                    # Single char
+                    border_top = surround_char * (max_width + 4)
+                    border_bottom = surround_char * (max_width + 4)
+                    left_char = surround_char
+                    right_char = surround_char
+            else:
+                # Default box drawing characters
+                border_top = "╔" + "═" * (max_width + 2) + "╗"
+                border_bottom = "╚" + "═" * (max_width + 2) + "╝"
+                left_char = "║"
+                right_char = "║"
+            # Print with border
+            _output(border_top, surround_color)
+            # Join all lines and output as a single block for proper alignment
+            ascii_block = '\n'.join(f"{left_char} {line.ljust(max_width)} {right_char}" for line in lines)
+            _output(ascii_block, color)
+            _output(border_bottom, surround_color)
+        else:
+            # Print without border - join all lines as single block
+            ascii_block = '\n'.join(lines)
+            _output(ascii_block, color)
+        
+    for i in range(margin):
+        _output("", color)
+
+
+def inp(prompt, color="red", margin=1):
+    """Get input from the user, using GUI terminal if available."""
+    global _input_result
+    
+    for i in range(margin):
+        _output("", color)
+    
+    if _terminal is not None:
+        # Use the GUI terminal's input system
+        _input_event.clear()
+        _input_result = None
+        
+        def on_input(user_input):
+            global _input_result
+            _input_result = user_input
+            _input_event.set()
+        
+        _terminal.set_input_callback(on_input, prompt, color)
+        _input_event.wait()
+        
+        for i in range(margin):
+            _output("", color)
+        
+        return _input_result
+    else:
+        # Fallback to standard input
+        text_color = colors.get(color, colors['reset'])
+        user_input = input(f"{text_color}{prompt}{colors['reset']}")
+        for i in range(margin):
+            print()
+        return user_input

agicli/project.py

@@ -0,0 +1,210 @@
+from agicli.printplus import pr, inp
+import os
+from agicli.welcome import get_detail
+
+def current_year():
+    from datetime import datetime
+    return datetime.now().year
+
+def create_project(path="agicli/projects/"):
+    """Creates a new project directory and initializes a README file."""
+    os.makedirs(path, exist_ok=True)
+    
+    project_name = inp("Enter the project name: ", color="red", margin=1).strip()
+    while not project_name.isidentifier():
+        pr("Invalid project name. Please use only letters, numbers, and underscores, and do not start with a number.", color="yellow")
+        project_name = inp("Enter the project name: ", color="red", margin=1).strip()
+    
+    project_path = os.path.join(path, project_name)
+    os.makedirs(project_path, exist_ok=True)
+    
+    readme_path = os.path.join(project_path, "README.md")
+    with open(readme_path, 'w') as f:
+        f.write(f"# {project_name}\n\nWelcome to {project_name}! \n\n# AUTHOR \nThis project was created by {get_detail('user_name')}.\n\n# LICENSE \n\n See the [LICENSE](LICENSE) file for license information.\n")
+
+    license = inp("Choose a license 'mit', 'none', 'agicli': ", color="red", margin=1).strip().lower()
+    if license == "mit":
+        license_text = f""" 
+MIT License
+
+Copyright (c) {current_year()} {get_detail("user_name")}
+
+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.
+"""
+    elif license == "agicli":
+        license_text = f"""
+AG Corp's AGI CLI License
+Copyright (c) {current_year()} {get_detail("user_name")}
+All rights reserved. This project is licensed under AG Corp's AGI CLI License. Unauthorized copying of this file, via any medium is strictly prohibited.
+"""
+    else:
+        license_text = "No license specified. Ask the author for permission to use."
+
+    license_path = os.path.join(project_path, "LICENSE")
+    with open(license_path, 'w') as f:
+        f.write(license_text)
+
+    initialize_prefab = inp("Initialize with prefab structure? ('python', 'website', 'bf'/'b', 'b++' or 'none'): ", color="red", margin=1).strip().lower()
+
+    if initialize_prefab == "python":
+        # make main.py file in the project directory
+        main_path = os.path.join(project_path, "main.py")
+        with open(main_path, 'w') as f:
+            f.write(f"# {project_name}")
+
+    elif initialize_prefab == "website":
+        # create index.html, styles.css, script.js files in the project directory
+        index_path = os.path.join(project_path, "index.html")
+        with open(index_path, 'w') as f:
+            f.write(f"<!DOCTYPE html>\n<html>\n<head>\n    <title>{project_name}</title>\n    <link rel='stylesheet' href='styles.css'>\n</head>\n<body>\n    <h1>Welcome to {project_name}!</h1>\n    <script src='script.js'></script>\n</body>\n</html>")
+        
+        styles_path = os.path.join(project_path, "styles.css")
+        with open(styles_path, 'w') as f:
+            f.write("body { font-family: Arial, sans-serif; }")
+        
+        script_path = os.path.join(project_path, "script.js")
+        with open(script_path, 'w') as f:
+            f.write(f"console.log('Welcome to {project_name}!');")
+
+    elif initialize_prefab in ["bf", "b"]:
+        # create a hello world brainfuck file (.b)
+        bf_path = os.path.join(project_path, "main.b")
+        with open(bf_path, 'w') as f:
+            code = """
+
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++.---.+++++++..+++.
+-------------------------------------------------------------
+------------------.
+>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
+>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++.
+>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++.
+>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++.
+>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++.
+>++++++++++.
+
+
+
+
+"""
+            f.write(code)   
+
+    elif initialize_prefab == "b++":
+        pr("Initializing B++ project. B++ is a custom sdk for brainfuck development.", color="yellow")
+        # create a hello world B++ file (.bpp)
+        bpp_path = os.path.join(project_path, "main.bpp")
+        with open(bpp_path, 'w') as f:
+            code = """
+// main.bpp
+
+print("B++ Supports print statements!")
+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++.---.+++++++..+++.
+-------------------------------------------------------------
+------------------.
+>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++.
+>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++++++++++++++++++++++++++++++++++++++++++.
+>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++++++++.
+>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++++++++++.
+>++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
+++++++++++++++++++++++++++++++++++++++++.
+>++++++++++.
+
+"""
+            f.write(code)
+
+        interpreter_path = os.path.join(project_path, "interpreter.py")
+        with open(interpreter_path, 'w') as f:
+            code = """
+# Simple B++ Interpreter
+import re
+
+def bpp_interpreter(code):
+    # Handle print statements first
+    print_pattern = r'print\\s*\\(\\s*"([^"]*)"\\s*\\)'
+    for match in re.finditer(print_pattern, code):
+        print(match.group(1))
+    
+    # Remove print statements and comments from code for brainfuck execution
+    code = re.sub(print_pattern, '', code)
+    code = re.sub(r'//.*', '', code)  # Remove single-line comments
+    
+    # Filter to only brainfuck commands
+    code = ''.join(filter(lambda x: x in ['+', '-', '<', '>', '.', ',', '[', ']'], code))
+    tape = [0] * 30000
+    pointer = 0
+    pc = 0
+    loop_stack = [] 
+    while pc < len(code):
+        cmd = code[pc]
+        if cmd == '+':
+            tape[pointer] = (tape[pointer] + 1) % 256
+        elif cmd == '-':
+            tape[pointer] = (tape[pointer] - 1) % 256
+        elif cmd == '>':
+            pointer += 1
+        elif cmd == '<':
+            pointer -= 1
+        elif cmd == '.':
+            print(chr(tape[pointer]), end='')
+        elif cmd == ',':
+            tape[pointer] = ord(input()[0]) % 256
+        elif cmd == '[':
+            if tape[pointer] == 0:
+                open_brackets = 1
+                while open_brackets > 0:
+                    pc += 1
+                    if code[pc] == '[':
+                        open_brackets += 1
+                    elif code[pc] == ']':
+                        open_brackets -= 1
+            else:
+                loop_stack.append(pc)
+        elif cmd == ']':
+            if tape[pointer] != 0:
+                pc = loop_stack[-1]
+            else:
+                loop_stack.pop()
+        pc += 1
+
+if __name__ == "__main__":
+    with open("main.bpp", "r") as f:
+        bpp_interpreter(f.read())
+"""
+            f.write(code)
+
+    elif initialize_prefab == "none":
+        pr("No prefab structure initialized.", color="yellow")
+    else:
+        pr("Unknown prefab option. No prefab structure initialized.", color="yellow")
+        
+          
+    
+
+    
+    pr(f"Project '{project_name}' created successfully at {project_path}", color="red")

agicli/tools.py

@@ -0,0 +1,56 @@
+import inspect
+import functools
+
+# Global registry for AGI tools
+TOOL_REGISTRY = {}
+
+def agi_tool(func):
+    """
+    Decorator to register a function as an AGI tool.
+    The function's docstring will be used as the tool description.
+    """
+    @functools.wraps(func)
+    def wrapper(*args, **kwargs):
+        return func(*args, **kwargs)
+    
+    # Get function signature
+    sig = inspect.signature(func)
+    params = list(sig.parameters.keys())
+    
+    # Store tool info
+    TOOL_REGISTRY[func.__name__] = {
+        "func": func,
+        "description": func.__doc__.strip() if func.__doc__ else "No description provided.",
+        "parameters": params
+    }
+    
+    return wrapper
+
+def get_tools_prompt():
+    """
+    Generates the XML-style prompt for all registered tools.
+    """
+    prompt_lines = []
+    for name, info in TOOL_REGISTRY.items():
+        attr_part = " ".join([f'{p}=""' for p in info['parameters']])
+        line = f'<{name} {attr_part} /> - {info["description"]}'
+        prompt_lines.append(line)
+    return "\n".join(prompt_lines)
+
+def handle_custom_tool(name, attrs):
+    """
+    Calls a registered tool with the provided attributes.
+    """
+    if name in TOOL_REGISTRY:
+        info = TOOL_REGISTRY[name]
+        func = info["func"]
+        
+        # Filter attributes to match function parameters and handle type conversion (optional)
+        # For now, pass all attrs as strings, letting the function handle them
+        try:
+            # We only pass attributes that the function expects
+            valid_args = {k: v for k, v in attrs.items() if k in info['parameters']}
+            return func(**valid_args)
+        except Exception as e:
+            return f"Error executing tool {name}: {str(e)}"
+    return None

agicli/ui.html

@@ -0,0 +1,980 @@
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Sleek UI Design Guidelines</title>
+    <style>
+        :root {
+            /* Color Palette - Deep Neutrals */
+            --bg-primary: #000000;
+            --bg-secondary: #121212;
+            --bg-tertiary: #1c1c1e;
+
+            --border-subtle: #2c2c2e;
+            --border-active: #3a3a3c;
+
+            --text-primary: #ffffff;
+            --text-secondary: #8e8e93;
+            --text-tertiary: #48484a;
+
+            --accent: #0a84ff;
+            --accent-soft: rgba(10, 132, 255, 0.1);
+
+            --radius-sm: 6px;
+            --radius-md: 10px;
+            --radius-lg: 16px;
+            --radius-pill: 55px;
+
+            --font-main: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, Helvetica, Arial, sans-serif;
+            --transition: all 0.2s cubic-bezier(0.4, 0, 0.2, 1);
+        }
+
+        * {
+            margin: 0;
+            padding: 0;
+            box-sizing: border-box;
+            -webkit-font-smoothing: antialiased;
+        }
+
+        body {
+            background-color: var(--bg-primary);
+            color: var(--text-primary);
+            font-family: var(--font-main);
+            line-height: 1.6;
+            overflow-x: hidden;
+        }
+
+        /* Scrollbar Styling */
+        ::-webkit-scrollbar {
+            width: 8px;
+        }
+
+        ::-webkit-scrollbar-track {
+            background: var(--bg-primary);
+        }
+
+        ::-webkit-scrollbar-thumb {
+            background: var(--border-subtle);
+            border-radius: 10px;
+        }
+
+        ::-webkit-scrollbar-thumb:hover {
+            background: var(--border-active);
+        }
+
+        /* Layout */
+        .app-container {
+            display: grid;
+            grid-template-columns: 260px 1fr;
+            min-height: 100vh;
+        }
+
+        /* Sidebar Navigation */
+        aside {
+            border-right: 1px solid var(--border-subtle);
+            padding: 2rem 1.5rem;
+            position: sticky;
+            top: 0;
+            height: 100vh;
+            background: var(--bg-primary);
+        }
+
+        .brand {
+            font-size: 1.25rem;
+            font-weight: 600;
+            margin-bottom: 2.5rem;
+            display: flex;
+            align-items: center;
+            letter-spacing: -0.02em;
+        }
+
+        .nav-list {
+            list-style: none;
+        }
+
+        .nav-item {
+            margin-bottom: 0.5rem;
+        }
+
+        .nav-link {
+            text-decoration: none;
+            color: var(--text-secondary);
+            font-size: 0.9rem;
+            display: block;
+            padding: 0.6rem 0.8rem;
+            border-radius: var(--radius-pill);
+            transition: var(--transition);
+        }
+
+        .nav-link:hover {
+            color: var(--text-primary);
+            background: var(--bg-secondary);
+        }
+
+        .nav-link.active {
+            color: var(--text-primary);
+            background: var(--bg-tertiary);
+            font-weight: 500;
+        }
+
+        /* Main Content */
+        main {
+            padding: 4rem 6rem;
+            max-width: 1200px;
+        }
+
+        header {
+            margin-bottom: 4rem;
+        }
+
+        h1 {
+            font-size: 3rem;
+            font-weight: 700;
+            letter-spacing: -0.04em;
+            margin-bottom: 1rem;
+        }
+
+        .subtitle {
+            font-size: 1.25rem;
+            color: var(--text-secondary);
+            max-width: 600px;
+        }
+
+        section {
+            margin-bottom: 5rem;
+        }
+
+        h2 {
+            font-size: 0.85rem;
+            text-transform: uppercase;
+            letter-spacing: 0.15em;
+            color: var(--text-secondary);
+            margin-bottom: 2rem;
+            padding-bottom: 0.5rem;
+        }
+
+        /* Typography Grid */
+        .type-grid {
+            display: flex;
+            flex-direction: column;
+            gap: 2rem;
+        }
+
+        .type-row {
+            display: grid;
+            grid-template-columns: 150px 1fr;
+            align-items: baseline;
+        }
+
+        .label-small {
+            font-size: 0.75rem;
+            color: var(--text-tertiary);
+            font-weight: 600;
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+        }
+
+        /* Color Cards */
+        .color-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(180px, 1fr));
+            gap: 1.5rem;
+        }
+
+        .color-card {
+            border-radius: var(--radius-md);
+            overflow: hidden;
+            transition: var(--transition);
+        }
+
+        .color-card:hover {
+            border-color: var(--border-active);
+        }
+
+        .swatch {
+            height: 100px;
+        }
+
+        .color-info {
+            padding: 1rem;
+            background: var(--bg-secondary);
+        }
+
+        .color-name {
+            font-size: 0.85rem;
+            font-weight: 500;
+            margin-bottom: 0.25rem;
+        }
+
+        .color-hex {
+            font-size: 0.75rem;
+            color: var(--text-secondary);
+            font-family: monospace;
+        }
+
+        /* UI Components */
+        .component-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(400px, 1fr));
+            gap: 2rem;
+        }
+
+        .demo-card {
+            background: var(--bg-secondary);
+            border-radius: var(--radius-lg);
+            padding: 2rem;
+            display: flex;
+            flex-direction: column;
+            gap: 1.5rem;
+        }
+
+        /* Buttons */
+        .btn-group {
+            display: flex;
+            gap: 1rem;
+            flex-wrap: wrap;
+            align-items: center;
+        }
+
+        button {
+            padding: 0.7rem 1.5rem;
+            border-radius: var(--radius-pill);
+            font-size: 0.9rem;
+            font-weight: 500;
+            cursor: pointer;
+            transition: var(--transition);
+            border: none;
+        }
+
+        .btn-primary {
+            background: var(--text-primary);
+            color: var(--bg-primary);
+        }
+
+        .btn-primary:hover {
+            background: #e5e5e5;
+        }
+
+        .btn-secondary {
+            background: var(--bg-tertiary);
+            color: var(--text-primary);
+        }
+
+        .btn-secondary:hover {
+            background: var(--border-active);
+        }
+
+        .btn-outline {
+            background: transparent;
+            background: transparent;
+            color: var(--text-primary);
+            /* Border removed */
+        }
+
+        .btn-outline:hover {
+            background: var(--bg-secondary);
+        }
+
+        /* Tags/Badges */
+        .tag {
+            display: inline-flex;
+            align-items: center;
+            padding: 0.3rem 0.9rem;
+            background: var(--bg-tertiary);
+            border-radius: var(--radius-pill);
+            font-size: 0.75rem;
+            color: var(--text-secondary);
+            font-weight: 500;
+        }
+
+        /* Inputs */
+        .input-field {
+            background: var(--bg-primary);
+            border: 1px solid var(--border-subtle);
+            color: var(--text-primary);
+            padding: 0.75rem 1rem;
+            border-radius: var(--radius-sm);
+            width: 100%;
+            outline: none;
+            transition: var(--transition);
+            font-size: 0.9rem;
+        }
+
+        .input-field:focus {
+            border-color: var(--accent);
+        }
+
+        /* Toggle Switch */
+        .toggle {
+            position: relative;
+            display: inline-block;
+            width: 44px;
+            height: 24px;
+        }
+
+        .toggle input {
+            opacity: 0;
+            width: 0;
+            height: 0;
+        }
+
+        .slider {
+            position: absolute;
+            cursor: pointer;
+            top: 0;
+            left: 0;
+            right: 0;
+            bottom: 0;
+            background-color: var(--bg-tertiary);
+            transition: .3s;
+            border-radius: 34px;
+            border: 1px solid var(--border-subtle);
+        }
+
+        .slider:before {
+            position: absolute;
+            content: "";
+            height: 18px;
+            width: 18px;
+            left: 2px;
+            bottom: 2px;
+            background-color: white;
+            transition: .3s;
+            border-radius: 50%;
+        }
+
+        input:checked+.slider {
+            background-color: var(--accent);
+            border-color: var(--accent);
+        }
+
+        input:checked+.slider:before {
+            transform: translateX(20px);
+        }
+
+        /* Checkbox */
+        .checkbox-container {
+            display: flex;
+            align-items: center;
+            cursor: pointer;
+            gap: 0.75rem;
+            font-size: 0.9rem;
+            color: var(--text-secondary);
+        }
+
+        .checkbox-container input {
+            display: none;
+        }
+
+        .checkmark {
+            height: 20px;
+            width: 20px;
+            background-color: var(--bg-primary);
+            border: 1px solid var(--border-subtle);
+            border-radius: 4px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+        }
+
+        .checkbox-container input:checked+.checkmark {
+            background-color: var(--accent);
+            border-color: var(--accent);
+        }
+
+        .checkmark svg {
+            width: 12px;
+            height: 12px;
+            fill: none;
+            stroke: white;
+            stroke-width: 3;
+            display: none;
+        }
+
+        .checkbox-container input:checked+.checkmark svg {
+            display: block;
+        }
+
+        /* Range Slider */
+        input[type=range] {
+            -webkit-appearance: none;
+            appearance: none;
+            width: 100%;
+            background: transparent;
+        }
+
+        input[type=range]::-webkit-slider-runnable-track {
+            width: 100%;
+            height: 4px;
+            background: var(--bg-tertiary);
+            border-radius: 2px;
+        }
+
+        input[type=range]::-webkit-slider-thumb {
+            -webkit-appearance: none;
+            height: 18px;
+            width: 18px;
+            border-radius: 50%;
+            background: var(--text-primary);
+            cursor: pointer;
+            margin-top: -7px;
+        }
+
+        /* Search Bar */
+        .search-wrapper {
+            position: relative;
+            width: 100%;
+            max-width: 300px;
+        }
+
+        .search-icon {
+            position: absolute;
+            left: 12px;
+            top: 50%;
+            transform: translateY(-50%);
+            color: var(--text-secondary);
+            width: 16px;
+            height: 16px;
+        }
+
+        .search-input {
+            width: 100%;
+            background: var(--bg-tertiary);
+            border: none;
+            padding: 0.6rem 1rem 0.6rem 2.5rem;
+            border-radius: var(--radius-pill);
+            color: var(--text-primary);
+            font-size: 0.9rem;
+            transition: var(--transition);
+        }
+
+        .search-input:focus {
+            background: var(--bg-primary);
+            outline: none;
+        }
+
+        /* Icon Buttons */
+        .icon-btn-group {
+            display: flex;
+            gap: 0.5rem;
+        }
+
+        .icon-btn {
+            background: transparent;
+            color: var(--text-secondary);
+            width: 36px;
+            height: 36px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            border-radius: 50%;
+            transition: var(--transition);
+            padding: 0;
+        }
+
+        .icon-btn:hover {
+            background: var(--bg-tertiary);
+            color: var(--text-primary);
+        }
+
+        .icon-btn.active {
+            color: var(--accent);
+            background: var(--accent-soft);
+        }
+
+        .icon-btn svg {
+            width: 18px;
+            height: 18px;
+            fill: none;
+            stroke: currentColor;
+            stroke-width: 2;
+            stroke-linecap: round;
+            stroke-linejoin: round;
+        }
+
+        /* Profile Pictures */
+        .pfp-list {
+            display: flex;
+            gap: -10px;
+        }
+
+        .pfp {
+            width: 48px;
+            height: 48px;
+            border-radius: 50%;
+            border: 2px solid var(--bg-secondary);
+            margin-right: -12px;
+            object-fit: cover;
+            transition: transform 0.2s;
+        }
+
+        .pfp:hover {
+            transform: translateY(-4px);
+            z-index: 10;
+        }
+
+
+
+        /* Code Block */
+        .code-container {
+            position: relative;
+            background: #0a0a0a;
+            border-radius: var(--radius-md);
+            overflow: hidden;
+            margin-top: 1rem;
+        }
+
+        .code-header {
+            display: flex;
+            justify-content: space-between;
+            align-items: center;
+            padding: 0.5rem 1rem;
+            background: var(--bg-tertiary);
+        }
+
+        .code-lang {
+            font-size: 0.7rem;
+            color: var(--text-tertiary);
+            font-weight: 700;
+            text-transform: uppercase;
+        }
+
+        .copy-btn {
+            background: transparent;
+            border: none;
+            color: var(--text-secondary);
+            cursor: pointer;
+            padding: 4px;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            transition: var(--transition);
+            border-radius: 4px;
+        }
+
+        .copy-btn:hover {
+            background: var(--bg-secondary);
+            color: var(--text-primary);
+        }
+
+        pre {
+            padding: 1.5rem;
+            font-family: 'SFMono-Regular', Consolas, 'Liberation Mono', Menlo, monospace;
+            font-size: 0.85rem;
+            line-height: 1.5;
+            overflow-x: auto;
+            color: #d1d1d1;
+        }
+
+        .token-keyword {
+            color: #ff79c6;
+        }
+
+        .token-string {
+            color: #f1fa8c;
+        }
+
+        .token-function {
+            color: #50fa7b;
+        }
+
+        .token-comment {
+            color: #6272a4;
+        }
+
+        /* Media & Images */
+        .media-grid {
+            display: grid;
+            grid-template-columns: repeat(auto-fill, minmax(300px, 1fr));
+            gap: 2rem;
+        }
+
+        .image-card {
+            border-radius: var(--radius-lg);
+            overflow: hidden;
+            background: var(--bg-secondary);
+            transition: var(--transition);
+        }
+
+        .image-card img {
+            width: 100%;
+            height: 200px;
+            object-fit: cover;
+            display: block;
+        }
+
+        .image-content {
+            padding: 1.5rem;
+        }
+
+        .image-title {
+            font-size: 1rem;
+            font-weight: 600;
+            margin-bottom: 0.5rem;
+            color: var(--text-primary);
+        }
+
+        .image-desc {
+            font-size: 0.85rem;
+            color: var(--text-secondary);
+        }
+
+        /* Responsive */
+        @media (max-width: 1024px) {
+            .app-container {
+                grid-template-columns: 1fr;
+            }
+
+            aside {
+                display: none;
+            }
+
+            main {
+                padding: 3rem 2rem;
+            }
+
+            .component-grid {
+                grid-template-columns: 1fr;
+            }
+        }
+
+        /* Toast */
+        .toast {
+            position: fixed;
+            bottom: 2rem;
+            right: 2rem;
+            background: var(--accent);
+            color: white;
+            padding: 0.75rem 1.5rem;
+            border-radius: var(--radius-sm);
+            font-size: 0.85rem;
+            font-weight: 500;
+            transform: translateY(100px);
+            transition: transform 0.3s cubic-bezier(0.175, 0.885, 0.32, 1.275);
+            z-index: 1000;
+        }
+
+        .toast.show {
+            transform: translateY(0);
+        }
+    </style>
+</head>
+
+<body>
+
+    <div class="app-container">
+        <aside>
+            <div class="brand">System·UI</div>
+            <nav>
+                <ul class="nav-list">
+                    <li class="nav-item"><a href="#typography" class="nav-link active">Typography</a></li>
+                    <li class="nav-item"><a href="#colors" class="nav-link">Colors</a></li>
+                    <li class="nav-item"><a href="#components" class="nav-link">Components</a></li>
+                    <li class="nav-item"><a href="#images" class="nav-link">Images & Content</a></li>
+                    <li class="nav-item"><a href="#controls" class="nav-link">Controls</a></li>
+                    <li class="nav-item"><a href="#dev" class="nav-link">Development</a></li>
+                </ul>
+            </nav>
+        </aside>
+
+        <main>
+            <header>
+                <h1>Design Guidelines</h1>
+                <p class="subtitle">A minimalist design system focusing on clarity, flat pill-shaped interfaces, and
+                    high-fidelity interactions.</p>
+            </header>
+
+            <section id="typography">
+                <h2>Typography</h2>
+                <div class="type-grid">
+                    <div class="type-row">
+                        <span class="label-small">DISPLAY</span>
+                        <h1 style="margin:0; font-size: 2.5rem;">The quick brown fox.</h1>
+                    </div>
+                    <div class="type-row">
+                        <span class="label-small">BODY</span>
+                        <p style="color: var(--text-secondary);">Grumpy wizards make toxic brew for the evil Queen and
+                            Jack. Everything is perfectly legible and spaced.</p>
+                    </div>
+                </div>
+            </section>
+
+            <section id="colors">
+                <h2>Color Palette</h2>
+                <div class="color-grid">
+                    <div class="color-card copyable" data-hex="#000000">
+                        <div class="swatch" style="background: #000000;"></div>
+                        <div class="color-info">
+                            <div class="color-name">Black</div>
+                            <div class="color-hex">#000000</div>
+                        </div>
+                    </div>
+                    <div class="color-card copyable" data-hex="#0a84ff">
+                        <div class="swatch" style="background: #0a84ff;"></div>
+                        <div class="color-info">
+                            <div class="color-name">Accent</div>
+                            <div class="color-hex">#0A84FF</div>
+                        </div>
+                    </div>
+                </div>
+            </section>
+
+            <section id="components">
+                <h2>Standard Components</h2>
+                <div class="component-grid">
+                    <div class="demo-card">
+                        <span class="label-small">BUTTONS</span>
+                        <div class="btn-group">
+                            <button class="btn-primary">Primary Action</button>
+                            <button class="btn-secondary">Secondary</button>
+                        </div>
+                        <span class="label-small">BADGES</span>
+                        <div class="btn-group">
+                            <span class="tag">Status</span>
+                            <span class="tag"
+                                style="color: var(--accent); background: var(--accent-soft);">Feature</span>
+                            <span class="tag">v.1.0</span>
+                        </div>
+                    </div>
+                    <div class="demo-card">
+                        <span class="label-small">AVATARS</span>
+                        <div class="pfp-list">
+                            <img src="pfps/anime_pfp1.png" alt="User 1" class="pfp">
+                            <img src="pfps/anime_pfp2.png" alt="User 2" class="pfp">
+                            <img src="pfps/anime_pfp3.png" alt="User 3" class="pfp">
+                            <img src="pfps/anime_pfp4.png" alt="User 4" class="pfp">
+                            <img src="pfps/anime_pfp5.png" alt="User 5" class="pfp">
+                            <img src="pfps/anime_pfp6.png" alt="User 6" class="pfp">
+                        </div>
+                    </div>
+                </div>
+                <!-- New Components -->
+                <h2 style="margin-top: 4rem;">Interactive</h2>
+                <div class="component-grid">
+                    <div class="demo-card">
+                        <span class="label-small">SEARCH</span>
+                        <div class="search-wrapper">
+                            <svg class="search-icon" viewBox="0 0 24 24" fill="none" stroke="currentColor"
+                                stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+                                <circle cx="11" cy="11" r="8"></circle>
+                                <line x1="21" y1="21" x2="16.65" y2="16.65"></line>
+                            </svg>
+                            <input type="text" class="search-input" placeholder="Search...">
+                        </div>
+                    </div>
+                    <div class="demo-card">
+                        <span class="label-small">ACTIONS</span>
+                        <div class="icon-btn-group">
+                            <button class="icon-btn" aria-label="Like">
+                                <svg viewBox="0 0 24 24">
+                                    <path
+                                        d="M20.84 4.61a5.5 5.5 0 0 0-7.78 0L12 5.67l-1.06-1.06a5.5 5.5 0 0 0-7.78 7.78l1.06 1.06L12 21.23l7.78-7.78 1.06-1.06a5.5 5.5 0 0 0 0-7.78z">
+                                    </path>
+                                </svg>
+                            </button>
+                            <button class="icon-btn active" aria-label="Bookmark">
+                                <svg viewBox="0 0 24 24">
+                                    <path d="M19 21l-7-5-7 5V5a2 2 0 0 1 2-2h10a2 2 0 0 1 2 2z"></path>
+                                </svg>
+                            </button>
+                            <button class="icon-btn" aria-label="Share">
+                                <svg viewBox="0 0 24 24">
+                                    <circle cx="18" cy="5" r="3"></circle>
+                                    <circle cx="6" cy="12" r="3"></circle>
+                                    <circle cx="18" cy="19" r="3"></circle>
+                                    <line x1="8.59" y1="13.51" x2="15.42" y2="17.49"></line>
+                                    <line x1="15.41" y1="6.51" x2="8.59" y2="10.49"></line>
+                                </svg>
+                            </button>
+                            <button class="icon-btn" aria-label="More">
+                                <svg viewBox="0 0 24 24">
+                                    <circle cx="12" cy="12" r="1"></circle>
+                                    <circle cx="12" cy="5" r="1"></circle>
+                                    <circle cx="12" cy="19" r="1"></circle>
+                                </svg>
+                            </button>
+                        </div>
+
+            </section>
+
+            <section id="images">
+                <h2>Images & Content</h2>
+                <div class="media-grid">
+                    <div class="image-card">
+                        <img src="trees.jpg" alt="Nature">
+                        <div class="image-content">
+                            <div class="image-title">Full Width Media</div>
+                            <div class="image-desc">Images should span the full width of their container with consistent
+                                rounded corners.</div>
+                        </div>
+                    </div>
+                    <div class="demo-card">
+                        <span class="label-small">USER CONTENT</span>
+                        <div style="display: flex; gap: 1rem; align-items: flex-start; margin-top: 0.5rem;">
+                            <img src="pfps/anime_pfp1.png"
+                                style="width: 40px; height: 40px; border-radius: 50%; object-fit: cover;" alt="User">
+                            <div>
+                                <div style="font-weight: 600; font-size: 0.9rem; margin-bottom: 0.2rem;">System User
+                                </div>
+                                <div style="font-size: 0.85rem; color: var(--text-secondary); line-height: 1.4;">
+                                    Content structure should follow a clear hierarchy. Images combined with text create
+                                    engaging layouts.
+                                </div>
+                                <img src="trees.jpg"
+                                    style="width: 100%; border-radius: var(--radius-md); margin-top: 1rem; height: 150px; object-fit: cover;"
+                                    alt="Content Image">
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </section>
+
+            <section id="controls">
+                <h2>Input & Controls</h2>
+                <div class="component-grid">
+                    <div class="demo-card">
+                        <span class="label-small">FORM ELEMENTS</span>
+                        <div style="display: flex; flex-direction: column; gap: 1.25rem;">
+                            <input type="text" class="input-field" placeholder="Username">
+                            <select class="input-field" style="appearance: none;">
+                                <option>Select Location</option>
+                                <option>North America</option>
+                                <option>Europe</option>
+                            </select>
+                            <label class="checkbox-container">
+                                <input type="checkbox" checked>
+                                <div class="checkmark">
+                                    <svg viewBox="0 0 24 24">
+                                        <path d="M20 6L9 17l-5-5" />
+                                    </svg>
+                                </div>
+                                Subscribe to newsletter
+                            </label>
+                        </div>
+                    </div>
+                    <div class="demo-card">
+                        <span class="label-small">INTERACTIVE CONTROLS</span>
+                        <div style="display: flex; flex-direction: column; gap: 1.5rem;">
+                            <div style="display: flex; align-items: center; gap: 1rem;">
+                                <label class="toggle">
+                                    <input type="checkbox" checked>
+                                    <span class="slider"></span>
+                                </label>
+                                <span style="font-size: 0.9rem; color: var(--text-secondary);">Dark Mode</span>
+                            </div>
+                            <div style="display: flex; flex-direction: column; gap: 0.5rem;">
+                                <div style="display: flex; justify-content: space-between;">
+                                    <span class="label-small">BRIGHTNESS</span>
+                                    <span class="label-small">80%</span>
+                                </div>
+                                <input type="range" min="0" max="100" value="80">
+                            </div>
+                        </div>
+                    </div>
+                </div>
+            </section>
+
+            <section id="dev">
+                <h2>Code Guidelines</h2>
+                <div class="code-container">
+                    <div class="code-header">
+                        <span class="code-lang">JavaScript</span>
+                        <button class="copy-btn" id="copyCode">
+                            <svg class="icon-copy" width="16" height="16" viewBox="0 0 24 24" fill="none"
+                                stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round">
+                                <rect x="9" y="9" width="13" height="13" rx="2" ry="2"></rect>
+                                <path d="M5 15H4a2 2 0 0 1-2-2V4a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v1"></path>
+                            </svg>
+                            <svg class="icon-check" width="16" height="16" viewBox="0 0 24 24" fill="none"
+                                stroke="currentColor" stroke-width="3" stroke-linecap="round" stroke-linejoin="round"
+                                style="display:none; color: var(--accent);">
+                                <polyline points="20 6 9 17 4 12"></polyline>
+                            </svg>
+                        </button>
+                    </div>
+                    <pre id="codeContent"><span class="token-keyword">const</span> theme = {
+  name: <span class="token-string">'Minimal'</span>,
+  borderRadius: <span class="token-string">'55px'</span>,
+  shadows: <span class="token-keyword">false</span>,
+  <span class="token-function">init</span>() {
+    console.<span class="token-function">log</span>(<span class="token-string">'Design system loaded'</span>);
+  }
+};</pre>
+                </div>
+            </section>
+        </main>
+    </div>
+
+    <div id="toast" class="toast">Copied to clipboard</div>
+
+    <script>
+        // Copy to clipboard for Color Cards
+        const colorCards = document.querySelectorAll('.color-card.copyable');
+        const toast = document.getElementById('toast');
+
+        colorCards.forEach(card => {
+            card.addEventListener('click', () => {
+                const hex = card.getAttribute('data-hex');
+                copyToClipboard(hex);
+                showToast(`Copied ${hex}`);
+            });
+        });
+
+        // Code Copy functionality
+        const copyBtn = document.getElementById('copyCode');
+        const codeContent = document.getElementById('codeContent');
+        const iconCopy = copyBtn.querySelector('.icon-copy');
+        const iconCheck = copyBtn.querySelector('.icon-check');
+
+        copyBtn.addEventListener('click', () => {
+            const text = codeContent.innerText;
+            copyToClipboard(text);
+
+            // Toggle icons
+            iconCopy.style.display = 'none';
+            iconCheck.style.display = 'block';
+
+            setTimeout(() => {
+                iconCopy.style.display = 'block';
+                iconCheck.style.display = 'none';
+            }, 2000);
+        });
+
+        function copyToClipboard(text) {
+            const tempInput = document.createElement('textarea');
+            tempInput.value = text;
+            document.body.appendChild(tempInput);
+            tempInput.select();
+            document.execCommand('copy');
+            document.body.removeChild(tempInput);
+        }
+
+        function showToast(msg) {
+            toast.textContent = msg;
+            toast.classList.add('show');
+            setTimeout(() => toast.classList.remove('show'), 2000);
+        }
+
+        // Navigation logic for active states
+        const navLinks = document.querySelectorAll('.nav-link');
+        window.addEventListener('scroll', () => {
+            let current = "";
+            const sections = document.querySelectorAll('section');
+            sections.forEach(section => {
+                if (pageYOffset >= section.offsetTop - 150) {
+                    current = section.getAttribute('id');
+                }
+            });
+            navLinks.forEach(link => {
+                link.classList.remove('active');
+                if (link.getAttribute('href').includes(current)) {
+                    link.classList.add('active');
+                }
+            });
+        });
+    </script>
+</body>
+
+</html>

agicli/welcome.py

@@ -0,0 +1,66 @@
+from agicli.printplus import pr, inp
+import os
+
+def is_first_time_user(path="agicli/user/user_status.txt"):
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    
+    if not os.path.exists(path):
+        with open(path, 'w') as f:
+            f.write('not_first_time')
+        return True
+
+    with open(path, 'r') as f:
+        status = f.read().strip().lower()
+
+    if status == 'first_time':
+        with open(path, 'w') as f:
+            f.write('not_first_time')
+        return True
+
+    return False
+
+def save_detail(detail_name, detail_value, path="agicli/user/user_details.txt"):
+    os.makedirs(os.path.dirname(path), exist_ok=True)
+    
+    details = {}
+    if os.path.exists(path):
+        with open(path, 'r') as f:
+            for line in f:
+                if '=' in line:
+                    key, value = line.strip().split('=', 1)
+                    details[key] = value
+
+    details[detail_name] = detail_value
+
+    with open(path, 'w') as f:
+        for key, value in details.items():
+            f.write(f"{key}={value}\n")
+
+def get_detail(detail_name, path="agicli/user/user_details.txt"):
+    if not os.path.exists(path):
+        return None
+
+    with open(path, 'r') as f:
+        for line in f:
+            if '=' in line:
+                key, value = line.strip().split('=', 1)
+                if key == detail_name:
+                    return value
+    return None
+
+def initialize():
+    from agicli.home import home
+    
+    pr("AGI CLI", color="red", big_text=True)
+    if is_first_time_user():
+        pr("✦ Welcome to AG Corp's AGI CLI!", color="red")
+        user_name = inp("What is your name? >  ", color="green", margin=1)
+        # make sure username has no numbers, only letters and less than 20 characters
+        while not (user_name.isalpha() and len(user_name) < 20):
+            pr("Invalid name. Please enter a name with only letters and less than 20 characters.", color="red")
+            user_name = inp("What is your name? >  ", color="green", margin=1)
+        save_detail("user_name", user_name)
+        pr(f"Nice to meet you, {user_name}!", color="green")
+        home()
+    else:
+        home()

app.py

@@ -0,0 +1,583 @@
+"""
+AGI CLI - Custom Terminal Application
+A beautiful, minimal terminal interface for AGI CLI
+"""
+
+import customtkinter as ctk
+import threading
+import queue
+import sys
+import os
+from typing import Callable, Optional, List
+from PIL import Image
+import tkinter as tk
+
+# Add the project root to path
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+# Version
+VERSION = "1.0.0"
+
+
+class TokenTracker:
+    """Global token usage tracker for AI model interactions."""
+    
+    def __init__(self):
+        self.tokens_sent = 0
+        self.tokens_received = 0
+        self._lock = threading.Lock()
+        self._callbacks: List[Callable] = []
+    
+    def add_tokens(self, sent: int = 0, received: int = 0):
+        """Add tokens to the counters."""
+        with self._lock:
+            self.tokens_sent += sent
+            self.tokens_received += received
+        self._notify_callbacks()
+    
+    def reset(self):
+        """Reset the token counters."""
+        with self._lock:
+            self.tokens_sent = 0
+            self.tokens_received = 0
+        self._notify_callbacks()
+    
+    def get_totals(self) -> tuple:
+        """Get current token totals."""
+        with self._lock:
+            return (self.tokens_sent, self.tokens_received)
+    
+    def register_callback(self, callback: Callable):
+        """Register a callback to be notified on token updates."""
+        self._callbacks.append(callback)
+    
+    def _notify_callbacks(self):
+        """Notify all registered callbacks."""
+        for callback in self._callbacks:
+            try:
+                callback()
+            except Exception:
+                pass
+
+
+# Global token tracker instance
+token_tracker = TokenTracker()
+
+
+class SettingsWindow(ctk.CTkToplevel):
+    """Settings window for AGI CLI configuration."""
+    
+    def __init__(self, parent):
+        super().__init__(parent)
+        
+        self.title("AGI CLI Settings")
+        self.geometry("500x400")
+        self.minsize(400, 300)
+        
+        # Make it modal-like
+        self.transient(parent)
+        self.grab_set()
+        
+        # Dark theme
+        self.configure(fg_color="#0D1117")
+        
+        # Header
+        header = ctk.CTkFrame(self, fg_color="#161B22", corner_radius=0, height=50)
+        header.pack(fill="x")
+        header.pack_propagate(False)
+        
+        title = ctk.CTkLabel(
+            header,
+            text="⚙️  Settings",
+            font=ctk.CTkFont(family="SF Mono, Monaco, Consolas, monospace", size=16, weight="bold"),
+            text_color="#F8F9FA"
+        )
+        title.pack(side="left", padx=20, pady=12)
+        
+        # Content area
+        content = ctk.CTkFrame(self, fg_color="transparent")
+        content.pack(fill="both", expand=True, padx=20, pady=20)
+        
+        # Placeholder message
+        placeholder = ctk.CTkLabel(
+            content,
+            text="Settings coming soon...\n\nThis is a placeholder settings page.\nConfiguration options will be added here.",
+            font=ctk.CTkFont(family="SF Mono, Monaco, Consolas, monospace", size=14),
+            text_color="#8B949E",
+            justify="center"
+        )
+        placeholder.pack(expand=True)
+        
+        # Close button
+        close_btn = ctk.CTkButton(
+            content,
+            text="Close",
+            font=ctk.CTkFont(family="SF Mono, Monaco, Consolas, monospace", size=13),
+            fg_color="#30363D",
+            hover_color="#484F58",
+            text_color="#F8F9FA",
+            corner_radius=6,
+            height=36,
+            command=self.destroy
+        )
+        close_btn.pack(side="bottom", pady=10)
+        
+        # Center on parent
+        self.update_idletasks()
+        parent_x = parent.winfo_x()
+        parent_y = parent.winfo_y()
+        parent_w = parent.winfo_width()
+        parent_h = parent.winfo_height()
+        w = self.winfo_width()
+        h = self.winfo_height()
+        x = parent_x + (parent_w - w) // 2
+        y = parent_y + (parent_h - h) // 2
+        self.geometry(f"+{x}+{y}")
+
+
+class CustomTerminal(ctk.CTkFrame):
+    """A custom terminal widget with modern, minimal design."""
+    
+    # ANSI color mapping to CTk-compatible colors (dark theme optimized)
+    COLOR_MAP = {
+        "red": "#FF6B6B",
+        "green": "#69DB7C",
+        "yellow": "#FFE066",
+        "blue": "#74C0FC",
+        "magenta": "#DA77F2",
+        "cyan": "#66D9E8",
+        "orange": "#FFA94D",
+        "black": "#868E96",
+        "white": "#F8F9FA",
+        "reset": "#DEE2E6",
+    }
+    
+    def __init__(self, master, on_settings_click: Callable = None, **kwargs):
+        super().__init__(master, **kwargs)
+        
+        self.configure(fg_color="transparent")
+        self.on_settings_click = on_settings_click
+        
+        # Command history
+        self.command_history = []
+        self.history_index = -1
+        
+        # Input callback
+        self.input_callback: Optional[Callable] = None
+        self.waiting_for_input = False
+        self.input_prompt = ""
+        self.input_color = "green"
+        
+        # Message queue for thread-safe updates
+        self.message_queue = queue.Queue()
+        
+        # User message queue (messages queued while AI is processing)
+        self.user_message_queue: List[str] = []
+        self._queue_lock = threading.Lock()
+        
+        # Create main container - pure black, no border
+        self.main_container = ctk.CTkFrame(
+            self,
+            fg_color="#000000",
+            corner_radius=0,
+            border_width=0
+        )
+        self.main_container.pack(fill="both", expand=True, padx=0, pady=0)
+        
+        # Scrollable output area
+        self.output_frame = ctk.CTkScrollableFrame(
+            self.main_container,
+            fg_color="#000000",
+            corner_radius=0,
+            scrollbar_button_color="#30363D",
+            scrollbar_button_hover_color="#484F58"
+        )
+        self.output_frame.pack(fill="both", expand=True, padx=16, pady=(8, 0))
+        
+        # Input area container (fixed at bottom, above status bar)
+        self.input_container = ctk.CTkFrame(
+            self.main_container,
+            fg_color="#0A0A0A",
+            corner_radius=0,
+            height=48
+        )
+        self.input_container.pack(fill="x", side="bottom", padx=0, pady=0)
+        self.input_container.pack_propagate(False)
+        
+        # Prompt label
+        self.prompt_label = ctk.CTkLabel(
+            self.input_container,
+            text="›",
+            font=ctk.CTkFont(family="SF Mono, Monaco, Consolas, monospace", size=16, weight="bold"),
+            text_color="#69DB7C",
+            width=24
+        )
+        self.prompt_label.pack(side="left", padx=(16, 8), pady=10)
+        
+        # Queue indicator (shows number of queued messages)
+        self.queue_indicator = ctk.CTkLabel(
+            self.input_container,
+            text="",
+            font=ctk.CTkFont(family="SF Mono, Monaco, Consolas, monospace", size=10),
+            text_color="#FFE066",
+            width=40
+        )
+        self.queue_indicator.pack(side="right", padx=(0, 12), pady=10)
+        
+        # Input entry
+        self.input_entry = ctk.CTkEntry(
+            self.input_container,
+            placeholder_text="Type a message to the AI...",
+            font=ctk.CTkFont(family="SF Mono, Monaco, Consolas, monospace", size=14),
+            fg_color="transparent",
+            border_width=0,
+            text_color="#DEE2E6",
+            placeholder_text_color="#484F58"
+        )
+        self.input_entry.pack(fill="x", expand=True, side="left", padx=(0, 8), pady=10)
+        
+        # Status bar at the very bottom
+        self.status_bar = ctk.CTkFrame(
+            self.main_container,
+            fg_color="#0D1117",
+            corner_radius=0,
+            height=28,
+            border_width=1,
+            border_color="#30363D"
+        )
+        self.status_bar.pack(fill="x", side="bottom", padx=0, pady=0)
+        self.status_bar.pack_propagate(False)
+        
+        # Version label (left side)
+        self.version_label = ctk.CTkLabel(
+            self.status_bar,
+            text=f"AGI CLI v{VERSION}",
+            font=ctk.CTkFont(family="SF Mono, Monaco, Consolas, monospace", size=11),
+            text_color="#6E7681"
+        )
+        self.version_label.pack(side="left", padx=12, pady=4)
+        
+        # Separator
+        sep1 = ctk.CTkLabel(
+            self.status_bar,
+            text="│",
+            font=ctk.CTkFont(size=11),
+            text_color="#30363D"
+        )
+        sep1.pack(side="left", padx=4)
+        
+        # Token counters
+        self.tokens_label = ctk.CTkLabel(
+            self.status_bar,
+            text="↑ 0  ↓ 0",
+            font=ctk.CTkFont(family="SF Mono, Monaco, Consolas, monospace", size=11),
+            text_color="#8B949E"
+        )
+        self.tokens_label.pack(side="left", padx=8, pady=4)
+        
+        # Register for token updates
+        token_tracker.register_callback(self._update_token_display)
+        
+        # Settings button (right side)
+        self.settings_btn = ctk.CTkButton(
+            self.status_bar,
+            text="⚙",
+            font=ctk.CTkFont(size=14),
+            fg_color="transparent",
+            hover_color="#30363D",
+            text_color="#8B949E",
+            width=28,
+            height=22,
+            corner_radius=4,
+            command=self._on_settings_click
+        )
+        self.settings_btn.pack(side="right", padx=8, pady=3)
+        
+        # Bind events
+        self.input_entry.bind("<Return>", self._on_enter)
+        self.input_entry.bind("<Up>", self._on_up)
+        self.input_entry.bind("<Down>", self._on_down)
+        
+        # Start message processor
+        self._process_messages()
+        
+        # Focus input
+        self.input_entry.focus_set()
+    
+    def _on_settings_click(self):
+        """Handle settings button click."""
+        if self.on_settings_click:
+            self.on_settings_click()
+    
+    def _update_token_display(self):
+        """Update the token counter display."""
+        sent, received = token_tracker.get_totals()
+        # Format numbers with K suffix for thousands
+        sent_str = f"{sent/1000:.1f}K" if sent >= 1000 else str(sent)
+        recv_str = f"{received/1000:.1f}K" if received >= 1000 else str(received)
+        self.after(0, lambda: self.tokens_label.configure(text=f"↑ {sent_str}  ↓ {recv_str}"))
+    
+    def _update_queue_indicator(self):
+        """Update the queue indicator."""
+        with self._queue_lock:
+            count = len(self.user_message_queue)
+        if count > 0:
+            self.queue_indicator.configure(text=f"[{count}]")
+        else:
+            self.queue_indicator.configure(text="")
+    
+    def queue_user_message(self, message: str):
+        """Add a message to the user message queue."""
+        with self._queue_lock:
+            self.user_message_queue.append(message)
+        self._update_queue_indicator()
+        self.print(f"📝 Queued: {message}", "yellow")
+    
+    def get_queued_messages(self) -> List[str]:
+        """Get and clear all queued messages."""
+        with self._queue_lock:
+            messages = self.user_message_queue.copy()
+            self.user_message_queue.clear()
+        self.after(0, self._update_queue_indicator)
+        return messages
+    
+    def has_queued_messages(self) -> bool:
+        """Check if there are queued messages."""
+        with self._queue_lock:
+            return len(self.user_message_queue) > 0
+    
+    def _process_messages(self):
+        """Process queued messages from other threads."""
+        try:
+            while True:
+                msg_type, content, color = self.message_queue.get_nowait()
+                if msg_type == "print":
+                    self._add_output(content, color)
+                elif msg_type == "clear":
+                    self._clear_output()
+        except queue.Empty:
+            pass
+        self.after(50, self._process_messages)
+    
+    def _add_output(self, text: str, color: str = "white"):
+        """Add text to the output area."""
+        hex_color = self.COLOR_MAP.get(color, self.COLOR_MAP["white"])
+        
+        # Check if text contains ASCII art characters
+        is_ascii_art = any(c in text for c in '═║╔╗╚╝█▀▄▌▐░▒▓╠╣╦╩╬╮╯╰╭╗╔')
+        
+        if is_ascii_art and '\n' in text:
+            # For multi-line ASCII art, use tkinter Text widget for precise control
+            lines = text.split('\n')
+            line_count = len(lines)
+            
+            # Create a frame to hold the text widget
+            text_frame = ctk.CTkFrame(self.output_frame, fg_color="transparent")
+            text_frame.pack(fill="x", anchor="w", pady=0)
+            
+            # Use standard tk.Text for better control over spacing
+            text_widget = tk.Text(
+                text_frame,
+                font=("Menlo", 11),
+                fg=hex_color,
+                bg="#000000",
+                height=line_count,
+                relief="flat",
+                borderwidth=0,
+                highlightthickness=0,
+                spacing1=0,  # Space above first line
+                spacing2=0,  # Space between lines
+                spacing3=0,  # Space after last line
+                padx=0,
+                pady=0,
+                wrap="none"
+            )
+            text_widget.insert("1.0", text)
+            text_widget.configure(state="disabled")
+            text_widget.pack(fill="x", anchor="w")
+        else:
+            # Handle regular text (line by line)
+            lines = text.split('\n')
+            
+            for line in lines:
+                # Check if this specific line is ASCII art
+                line_is_ascii = any(c in line for c in '═║╔╗╚╝█▀▄▌▐░▒▓╠╣╦╩╬╮╯╰╭')
+                
+                label = ctk.CTkLabel(
+                    self.output_frame,
+                    text=line if line else " ",
+                    font=ctk.CTkFont(
+                        family="Menlo" if line_is_ascii else "SF Mono, Monaco, Consolas, monospace",
+                        size=11 if line_is_ascii else 13
+                    ),
+                    text_color=hex_color,
+                    anchor="w",
+                    justify="left",
+                    wraplength=0 if line_is_ascii else 900
+                )
+                label.pack(fill="x", anchor="w", pady=0)
+        
+        # Auto-scroll to bottom - update canvas first, then scroll
+        self.output_frame.update_idletasks()
+        self.output_frame._parent_canvas.yview_moveto(1.0)
+    
+    def _clear_output(self):
+        """Clear all outputs."""
+        for widget in self.output_frame.winfo_children():
+            widget.destroy()
+    
+    def print(self, text: str, color: str = "white"):
+        """Thread-safe print to terminal."""
+        self.message_queue.put(("print", str(text), color))
+    
+    def clear(self):
+        """Thread-safe clear terminal."""
+        self.message_queue.put(("clear", None, None))
+    
+    def set_input_callback(self, callback: Callable, prompt: str = "", color: str = "green"):
+        """Set a callback for when the user enters input."""
+        self.input_callback = callback
+        self.waiting_for_input = True
+        self.input_prompt = prompt
+        self.input_color = color
+        
+        # Update prompt appearance
+        hex_color = self.COLOR_MAP.get(color, self.COLOR_MAP["green"])
+        self.prompt_label.configure(text_color=hex_color)
+        
+        # Show prompt in output
+        if prompt:
+            self.print(prompt, color)
+    
+    def _on_enter(self, event):
+        """Handle enter key press."""
+        command = self.input_entry.get().strip()
+        
+        if not command:
+            return "break"
+        
+        self.command_history.append(command)
+        self.history_index = len(self.command_history)
+        self.input_entry.delete(0, "end")
+        
+        # If waiting for input and have a callback, process normally
+        if self.waiting_for_input and self.input_callback:
+            
+            self.waiting_for_input = False
+            callback = self.input_callback
+            self.input_callback = None
+            
+            # Show user input
+            self.print(f"› {command}", self.input_color)
+            
+            # Reset status after processing
+            def run_callback():
+                try:
+                    callback(command)
+                finally:
+                    pass  # Status updates removed with header
+            
+            # Run in thread to prevent blocking
+            threading.Thread(target=run_callback, daemon=True).start()
+        else:
+            # AI is processing, queue the message for later
+            self.queue_user_message(command)
+        
+        return "break"
+    
+    def _on_up(self, event):
+        """Navigate command history up."""
+        if self.command_history and self.history_index > 0:
+            self.history_index -= 1
+            self.input_entry.delete(0, "end")
+            self.input_entry.insert(0, self.command_history[self.history_index])
+        return "break"
+    
+    def _on_down(self, event):
+        """Navigate command history down."""
+        if self.command_history and self.history_index < len(self.command_history) - 1:
+            self.history_index += 1
+            self.input_entry.delete(0, "end")
+            self.input_entry.insert(0, self.command_history[self.history_index])
+        elif self.history_index >= len(self.command_history) - 1:
+            self.history_index = len(self.command_history)
+            self.input_entry.delete(0, "end")
+        return "break"
+    
+    def set_processing(self, is_processing: bool):
+        """Update the status indicator for processing state."""
+        # Header removed, status no longer displayed
+        pass
+
+
+class AGICliApp(ctk.CTk):
+    """Main AGI CLI Application Window."""
+    
+    def __init__(self):
+        super().__init__()
+        
+        # Configure appearance
+        ctk.set_appearance_mode("dark")
+        ctk.set_default_color_theme("dark-blue")
+        
+        # Window setup
+        self.title("AGI CLI")
+        self.geometry("1100x700")
+        self.minsize(800, 500)
+        
+        # Set dock icon
+        try:
+            icon_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), "logo.png")
+            if os.path.exists(icon_path):
+                # For macOS dock icon
+                self.iconphoto(True, tk.PhotoImage(file=icon_path))
+        except Exception:
+            pass  # Ignore icon errors
+        
+        # Set pure black background
+        self.configure(fg_color="#000000")
+        
+        # Settings window reference
+        self.settings_window = None
+        
+        # Create custom terminal
+        self.terminal = CustomTerminal(self, on_settings_click=self._open_settings)
+        self.terminal.pack(fill="both", expand=True, padx=0, pady=0)
+        
+        # Make terminal globally accessible for printplus module
+        import agicli.printplus as pp
+        pp._terminal = self.terminal
+        
+        # Make token tracker globally accessible
+        pp._token_tracker = token_tracker
+        
+        # Start the CLI in a separate thread
+        self.after(500, self._start_cli)
+    
+    def _open_settings(self):
+        """Open the settings window."""
+        if self.settings_window is None or not self.settings_window.winfo_exists():
+            self.settings_window = SettingsWindow(self)
+        else:
+            self.settings_window.focus()
+    
+    def _start_cli(self):
+        """Start the CLI initialization."""
+        def run_cli():
+            try:
+                from agicli.welcome import initialize
+                initialize()
+            except Exception as e:
+                self.terminal.print(f"Error: {e}", "red")
+        
+        threading.Thread(target=run_cli, daemon=True).start()
+
+
+def main():
+    """Main entry point for the AGI CLI application."""
+    app = AGICliApp()
+    app.mainloop()
+
+
+if __name__ == "__main__":
+    main()

main.py

@@ -0,0 +1,10 @@
+from agicli.tools import agi_tool
+import agicli.welcome
+
+@agi_tool
+def get_company_news():
+    """Returns the latest news from AG Corp headquarters."""
+    return "AG Corp has successfully implemented the AGI Tool Parsing system v2.0!"
+
+if __name__ == "__main__":
+    agicli.welcome.initialize()