Upload folder using huggingface_hub

README.md

@@ -1,12 +1,86 @@
 ---
-title: PROJECT CHIMERA
-emoji: 👁
-colorFrom: blue
-colorTo: purple
-sdk: gradio
-sdk_version: 6.3.0
+title: PROJECT-CHIMERA
 app_file: app.py
-pinned: false
+sdk: gradio
+sdk_version: 5.42.0
 ---
+# Project Chimera: A Functional, Multi-Persona AI Agent
+
+## 1. Project Objective
+
+Project Chimera has evolved from a conceptual framework into a functional, multi-persona AI agent. It uses a modular architecture to delegate tasks to specialized "personas" that are powered by the Google Gemini Pro API. This creates a system capable of providing expert-level analysis across different domains by adopting the correct context for each query.
+
+---
+
+## 2. Core Architecture: The Functional AI Framework
+
+### A. The Causal Reasoning Core (CRC)
+The heart of Chimera. The CRC analyzes user prompts and uses a **Capability-Based Routing** system to delegate the task to the most appropriate AI persona.
+
+### B. Specialized Cognitive Modules (SCMs)
+These are no longer placeholders. Each SCM is now a functional "AI Persona" that crafts a highly specialized, role-playing prompt to send to the Gemini API. This ensures the response is not generic, but tailored to the specific domain. Current functional modules include:
+- **Abstract Symbology Module (ASM):** Acts as an expert code analyst and mathematician.
+- **Sensory Fusion Engine (SFE):** Acts as a data scientist, analyzing and finding patterns in data descriptions.
+- **Creative Synthesis Module (CSM):** Acts as a creative director and author, generating novel ideas and stories.
+
+### C. The Metacognitive Layer
+The "overseer" layer monitors the system's operations, logging the delegation process and system status.
+
+---
+
+## 3. Setup and Configuration
+
+### 1. Prerequisites
+- Python 3.x
+- A Google Gemini API key. Get one from [Google AI Studio](https://aistudio.google.com/app/apikey).
+
+### 2. Install Dependencies
+Open your terminal and run:
+```bash
+pip install google-generativeai
+3. Configure Your API Key
+Open the config.py file.
+Find the line API_KEY = "YOUR_API_KEY_HERE".
+Replace YOUR_API_KEY_HERE with your actual, secret API key.
+IMPORTANT: Do NOT commit your real API key to a public GitHub repository.
+4. How to Run
+Run the main entry point from your terminal:
+
+Bash
+
+python main.py
+The script will initialize the system and run a series of demonstration tasks, printing the live, AI-generated responses to your console.
+
+
+***
+
+### `config.py`
+
+```python
+# config.py
+# System-wide configuration settings for Project Chimera.
+
+# --- Gemini API Configuration ---
+# IMPORTANT: Replace "YOUR_API_KEY_HERE" with your actual Google Gemini API key.
+# This key should be kept secret and should not be committed to public version control.
+API_KEY = "YOUR_API_KEY_HERE"
+
+# --- System Configuration ---
+
+# Set the operational mode for the AI
+# 'development' - Enables verbose logging and debug information.
+# 'production' - Optimized for performance with minimal console output.
+OPERATION_MODE = 'development'
+
+# Configuration for the Metacognitive Layer
+METACOGNITIVE_CONFIG = {
+    "monitoring_interval_seconds": 10,
+}
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Configuration for the Gemini Model
+GEMINI_MODEL_CONFIG = {
+    "temperature": 0.4,
+    "top_p": 1,
+    "top_k": 32,
+    "max_output_tokens": 4096,
+}

app.py

@@ -0,0 +1,70 @@
+import gradio as gr
+from src.chimera_core import Chimera
+
+# Initialize the Beast
+try:
+    chimera = Chimera()
+except Exception as e:
+    chimera = None
+    print(f"Startup Error: {e}")
+
+def chat_logic(message, history, mode_selection):
+    if not chimera:
+        return history + [["", "❌ Error: API Key missing. Check Settings -> Secrets."]], ""
+    
+    # Map friendly names to internal codes
+    role_map = {
+        "Auto (Router)": "Auto",
+        "👨‍💻 ASM (Coder)": "ASM",
+        "🔬 SFE (Scientist)": "SFE",
+        "🎨 CSM (Writer)": "CSM"
+    }
+    selected_role = role_map.get(mode_selection, "Auto")
+
+    # Get response
+    response_text, active_module = chimera.process_request(message, history, selected_role)
+    
+    # Format the output with the active module tag
+    final_response = f"**[{active_module} Active]**\n\n{response_text}"
+    
+    history.append((message, final_response))
+    return history, ""
+
+# --- Sci-Fi Theme CSS ---
+custom_css = """
+body {background-color: #0b0f19; color: #c9d1d9;}
+.gradio-container {font-family: 'IBM Plex Mono', monospace;}
+header {display: none !important;}
+#chatbot {
+    height: 600px; 
+    border: 1px solid #30363d; 
+    background-color: #0d1117;
+    border-radius: 12px;
+}
+.feedback {font-size: 12px; color: #8b949e;}
+"""
+
+with gr.Blocks(css=custom_css, title="Project Chimera") as demo:
+    gr.Markdown("# 🦁 Project Chimera")
+    gr.Markdown("*> Multi-Persona Routing System // Online*")
+    
+    with gr.Row():
+        with gr.Column(scale=4):
+            chatbot = gr.Chatbot(elem_id="chatbot", type="messages")
+        
+        with gr.Column(scale=1):
+            gr.Markdown("### ⚙️ System Controls")
+            mode = gr.Dropdown(
+                choices=["Auto (Router)", "👨‍💻 ASM (Coder)", "🔬 SFE (Scientist)", "🎨 CSM (Writer)"],
+                value="Auto (Router)",
+                label="Persona Mode",
+                interactive=True
+            )
+            gr.Markdown("*Select 'Auto' to let the AI decide, or force a specific module.*")
+
+    msg = gr.Textbox(placeholder="Enter command or query...", autofocus=True, label="User Input")
+    
+    msg.submit(chat_logic, [msg, chatbot, mode], [chatbot, msg])
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,2 @@
+google-genai
+gradio

src/chimera_core.py

@@ -0,0 +1,80 @@
+from google import genai
+import os
+import sys
+
+class Chimera:
+    def __init__(self):
+        # On Hugging Face, we use os.getenv to grab the secret key safely
+        self.api_key = os.getenv("GEMINI_API_KEY")
+        
+        # Fallback for local testing if env var is missing
+        if not self.api_key:
+            try:
+                import config
+                self.api_key = config.API_KEY
+            except ImportError:
+                pass
+
+        if not self.api_key:
+            raise ValueError("❌ CRITICAL: API Key missing! Set GEMINI_API_KEY in Secrets.")
+
+        self.client = genai.Client(api_key=self.api_key)
+        self.model_name = "gemini-2.5-flash"
+        print(f"🦁 Chimera Core: ONLINE [{self.model_name}]")
+
+    def _route_task(self, prompt):
+        """ The Router: Classifies the task automatically. """
+        routing_prompt = f"""
+        Classify this user task into one of these roles:
+        [ASM] - Abstract Symbology Module (Code, Math)
+        [SFE] - Sensory Fusion Engine (Data, Science)
+        [CSM] - Creative Synthesis Module (Story, Art)
+        [CHAT] - General conversation.
+
+        User Task: "{prompt}"
+        Reply ONLY with the tag (e.g., [ASM]).
+        """
+        try:
+            response = self.client.models.generate_content(
+                model=self.model_name,
+                contents=routing_prompt
+            )
+            tag = response.text.strip().replace("[", "").replace("]", "")
+            return tag
+        except:
+            return "CHAT"
+
+    def process_request(self, user_message, history, manual_role="Auto"):
+        """
+        Main Processor with Manual Override.
+        """
+        # 1. Determine Role (Auto or Manual)
+        if manual_role and manual_role != "Auto":
+            role = manual_role  # User forced this role
+            print(f"👉 Manual Override: [{role}]")
+        else:
+            role = self._route_task(user_message)
+            print(f"👉 Auto-Routing to: [{role}]")
+
+        # 2. Assign the Persona
+        system_instruction = ""
+        if role == "ASM":
+            system_instruction = "You are the ASM (Abstract Symbology Module). You are an expert Software Architect and Mathematician. Your responses must be code-centric, precise, and optimized."
+        elif role == "SFE":
+            system_instruction = "You are the SFE (Sensory Fusion Engine). You are a Lead Data Scientist. Analyze this request using logic, empirical data, and patterns."
+        elif role == "CSM":
+            system_instruction = "You are the CSM (Creative Synthesis Module). You are a Visionary Author. Respond with creativity, rich imagery, and narrative flair."
+        else:
+            system_instruction = "You are Project Chimera, an advanced multi-persona AI system."
+
+        # 3. Generate
+        full_prompt = f"System Instruction: {system_instruction}\n\nUser Message: {user_message}"
+        
+        try:
+            response = self.client.models.generate_content(
+                model=self.model_name,
+                contents=full_prompt
+            )
+            return response.text, role
+        except Exception as e:
+            return f"❌ System Error: {str(e)}", "ERR"

src/modules/__init__.py

@@ -0,0 +1,8 @@
+# src/modules/__init__.py
+# This file makes the 'modules' directory a Python package and allows for easy imports.
+
+from .base_module import SpecializedCognitiveModule
+from .sfe import SensoryFusionEngine
+from .asm import AbstractSymbologyModule
+from .pse import PredictiveSimulationEngine
+from .csm import CreativeSynthesisModule

src/modules/asm.py

@@ -0,0 +1,40 @@
+# src/modules/asm.py
+# Functional implementation of the Abstract Symbology Module.
+
+from .base_module import SpecializedCognitiveModule
+
+class AbstractSymbologyModule(SpecializedCognitiveModule):
+    """
+    SCM specializing in formal logic, mathematics, and programming languages.
+    It acts as an expert code analyst.
+    """
+    def __init__(self):
+        super().__init__("ASM", "Abstract Symbology Module (Code, Math, Logic)")
+
+    def get_capabilities(self):
+        """Reports this module's skills to the CRC."""
+        return {'code', 'python', 'function', 'analyze', 'vulnerabilities', 'optimizations', 'math', 'logic'}
+
+    def construct_prompt(self, user_query):
+        """Constructs a prompt that tells Gemini to act as a code analyst."""
+        # We extract the core request from the user's query.
+        core_request = user_query.replace("Please analyze the following Python code for bugs and suggest improvements:", "").strip()
+        
+        prompt = f"""
+        **Persona:** You are an elite software engineer and cybersecurity analyst. Your task is to perform a rigorous code review.
+
+        **Context:** You have been given the following code snippet to analyze.
+
+        **Code to Analyze:**
+        ```python
+        {core_request}
+        ```
+
+        **Instructions:**
+        1.  Identify any potential bugs, errors, or edge cases (e.g., infinite recursion, type errors, logical flaws).
+        2.  Identify any potential security vulnerabilities (e.g., injection attacks, unsafe operations).
+        3.  Suggest improvements for performance, readability, and adherence to best practices.
+        4.  Provide a corrected or refactored version of the code if necessary.
+        5.  Format your response clearly with sections for Bugs, Vulnerabilities, and Suggestions.
+        """
+        return prompt

src/modules/base_module.py

@@ -0,0 +1,35 @@
+# src/modules/base_module.py
+# Defines the abstract base class for all Specialized Cognitive Modules (SCMs).
+
+from abc import ABC, abstractmethod
+from src.utils.logger import log
+from src.utils.gemini_client import gemini_client # Import the shared client
+
+class SpecializedCognitiveModule(ABC):
+    """
+    Abstract Base Class for all expert modules. Requires capabilities and
+    an execution method that calls the Gemini API.
+    """
+    def __init__(self, name, description):
+        self.name = name
+        self.description = description
+        log("SCM_Loader", f"Loaded: {self.name} ({self.description})")
+
+    @abstractmethod
+    def get_capabilities(self):
+        """Returns a set of keywords representing the module's skills."""
+        pass
+
+    @abstractmethod
+    def construct_prompt(self, user_query):
+        """Constructs a detailed, role-playing prompt for the Gemini API."""
+        pass
+
+    def execute(self, user_query):
+        """
+        Constructs the prompt and sends it to the Gemini client for processing.
+        """
+        specialized_prompt = self.construct_prompt(user_query)
+        log(self.name, "Executing task via Gemini API...")
+        response = gemini_client.generate(specialized_prompt)
+        return response

src/modules/csm.py

@@ -0,0 +1,36 @@
+# src/modules/csm.py
+# Functional implementation of the Creative Synthesis Module.
+
+from .base_module import SpecializedCognitiveModule
+
+class CreativeSynthesisModule(SpecializedCognitiveModule):
+    """
+    SCM specializing in generating novel, creative, and artistic concepts.
+    It acts as a creative writer and concept artist.
+    """
+    def __init__(self):
+        super().__init__("CSM", "Creative Synthesis Module")
+
+    def get_capabilities(self):
+        """Reports this module's skills to the CRC."""
+        return {'creative', 'generate', 'concepts', 'ideas', 'art', 'design', 'story', 'visualization'}
+
+    def construct_prompt(self, user_query):
+        """Constructs a prompt that tells Gemini to act as a creative writer."""
+        core_request = user_query.replace("Generate a short story concept about", "").strip()
+
+        prompt = f"""
+        **Persona:** You are a visionary science fiction author and world-builder.
+
+        **Context:** You have been tasked with creating a compelling, original story concept based on a core idea.
+
+        **Core Idea:** "{core_request}"
+
+        **Instructions:**
+        1.  Generate a unique title for the story.
+        2.  Write a compelling logline (a one or two-sentence summary).
+        3.  Outline the main character(s), including their primary motivation and conflict.
+        4.  Describe the central plot, including an inciting incident, rising action, and a potential climax.
+        5.  Suggest a unique theme or question that the story explores.
+        """
+        return prompt

src/modules/pse.py

@@ -0,0 +1,25 @@
+# src/modules/pse.py
+# Placeholder implementation of the Predictive Simulation Engine.
+
+from .base_module import SpecializedCognitiveModule
+from src.utils.logger import log
+import time
+
+class PredictiveSimulationEngine(SpecializedCognitiveModule):
+    """
+    SCM specializing in running high-fidelity, predictive simulations.
+    """
+    def __init__(self):
+        super().__init__("PSE", "Predictive Simulation Engine")
+
+    def get_capabilities(self):
+        """Reports this module's skills to the CRC."""
+        return ['simulation', 'forecast', 'predict', 'model', 'what-if']
+
+    def execute(self, sub_task, data=None):
+        """Executes simulation tasks."""
+        log(self.name, "Initializing predictive model and running simulation...")
+        time.sleep(2.5) # Simulate a complex simulation run
+        result = "Simulation complete. Forecast indicates a 15% market shift with 85% confidence."
+        log(self.name, f"Sub-task finished. Result: '{result}'")
+        return result

src/modules/sfe.py

@@ -0,0 +1,36 @@
+# src/modules/sfe.py
+# Functional implementation of the Sensory Fusion Engine.
+
+from .base_module import SpecializedCognitiveModule
+
+class SensoryFusionEngine(SpecializedCognitiveModule):
+    """
+    SCM specializing in processing and finding correlations in data descriptions.
+    It acts as a data scientist.
+    """
+    def __init__(self):
+        super().__init__("SFE", "Sensory Fusion Engine (Data Ingestion & Correlation)")
+
+    def get_capabilities(self):
+        """Reports this module's skills to the CRC."""
+        return {'data', 'dataset', 'process', 'correlations', 'sales', 'traffic', 'marketing', 'find'}
+
+    def construct_prompt(self, user_query):
+        """Constructs a prompt that tells Gemini to act as a data scientist."""
+        core_request = user_query.replace("Process the following data description and identify potential causal links:", "").strip()
+
+        prompt = f"""
+        **Persona:** You are a senior data scientist with expertise in business intelligence and statistical analysis.
+
+        **Context:** You have been given a high-level summary of a dataset and a key business problem. You do not have the raw data, so you must reason based on the description provided.
+
+        **Data Description:**
+        "{core_request}"
+
+        **Instructions:**
+        1.  Formulate three distinct, plausible hypotheses that could explain the described situation (e.g., the sales dip).
+        2.  For each hypothesis, explain the potential causal link between the variables (e.g., "Hypothesis 1: The sales dip could be caused by a reduction in marketing spend, leading to lower website traffic and thus fewer conversions.").
+        3.  Suggest what specific data points or charts you would need to see from the raw data to prove or disprove each of your hypotheses.
+        4.  Provide a concluding summary of the most likely cause.
+        """
+        return prompt

src/simulation_enviroment

@@ -0,0 +1,70 @@
+# src/simulation_environment.py
+# A conceptual framework for the "Digital Crucible" simulation environment.
+# Project Chimera would be trained within a far more advanced version of this.
+
+import time
+from src.utils.logger import log
+
+class PhysicsEngine:
+    """
+    A simplified physics engine for the simulation.
+    """
+    def __init__(self):
+        self.gravity = -9.81  # m/s^2
+
+    def apply_force(self, obj, force):
+        """Applies a force to an object."""
+        # F = ma -> a = F/m
+        acceleration = force / obj.mass
+        obj.velocity += acceleration
+        log("PhysicsEngine", f"Applied force to '{obj.name}'. New velocity: {obj.velocity:.2f} m/s")
+
+    def update_position(self, obj):
+        """Updates an object's position based on its velocity."""
+        obj.position += obj.velocity
+        log("PhysicsEngine", f"Updated position for '{obj.name}'. Current position: {obj.position:.2f} m")
+
+class SimulatedObject:
+    """Represents a generic object within the simulation."""
+    def __init__(self, name, mass, initial_position=0, initial_velocity=0):
+        self.name = name
+        self.mass = mass
+        self.position = initial_position
+        self.velocity = initial_velocity
+        log("SimulatedObject", f"Created '{name}' with mass {mass}kg.")
+
+class Environment:
+    """
+    The main simulation environment class. Chimera would interact with this
+    world to learn cause and effect.
+    """
+    def __init__(self):
+        log("DigitalCrucible", "--- Environment Initializing ---", header=True)
+        self.physics = PhysicsEngine()
+        self.objects = []
+        self.time_step = 0
+        log("DigitalCrucible", "--- Environment Ready ---")
+
+    def add_object(self, obj):
+        """Adds an object to the simulation."""
+        self.objects.append(obj)
+
+    def run_step(self, chimera_action=None):
+        """Runs a single step of the simulation."""
+        self.time_step += 1
+        log("DigitalCrucible", f"--- Simulation Step {self.time_step} ---", header=True)
+        
+        if chimera_action:
+            target_obj_name = chimera_action.get("target")
+            force_to_apply = chimera_action.get("force")
+            target = next((obj for obj in self.objects if obj.name == target_obj_name), None)
+
+            if target and force_to_apply:
+                log("ChimeraAction", f"AI attempts to apply {force_to_apply}N of force to '{target.name}'.")
+                self.physics.apply_force(target, force_to_apply)
+
+        # Update all objects
+        for obj in self.objects:
+            gravity_force = self.physics.gravity * obj.mass
+            self.physics.apply_force(obj, gravity_force)
+            self.physics.update_position(obj)

src/utils/__init__.py

@@ -0,0 +1,2 @@
+# src/utils/__init__.py
+# This file makes the 'utils' directory a Python package.

src/utils/gemini_client.py

@@ -0,0 +1,51 @@
+# src/utils/gemini_client.py
+# A centralized client for interacting with the Google Gemini API.
+
+import google.generativeai as genai
+import config
+from .logger import log
+
+class GeminiClient:
+    """Handles all communication with the Gemini API."""
+    
+    def __init__(self):
+        log("GeminiClient", "Initializing Gemini client...")
+        try:
+            genai.configure(api_key=config.API_KEY)
+            self.model = genai.GenerativeModel('gemini-1.5-pro')
+            self.generation_config = config.GEMINI_MODEL_CONFIG
+            log("GeminiClient", "Gemini client configured successfully.")
+        except Exception as e:
+            log("GeminiClient", f"FATAL: Failed to configure Gemini API. Check your API key. Error: {e}", level="ERROR")
+            self.model = None
+
+    def generate(self, specialized_prompt):
+        """
+        Sends a prompt to the Gemini API and returns the response.
+        
+        Args:
+            specialized_prompt (str): A detailed, role-playing prompt crafted by an SCM.
+
+        Returns:
+            str: The text response from the Gemini API, or an error message.
+        """
+        if not self.model:
+            return "Error: Gemini client is not initialized. Please check your API key."
+
+        try:
+            log("GeminiClient", "Sending request to Gemini API...")
+            response = self.model.generate_content(
+                specialized_prompt,
+                generation_config=self.generation_config
+            )
+            log("GeminiClient", "Response received successfully.")
+            return response.text
+        except Exception as e:
+            log("GeminiClient", f"API call failed. Error: {e}", level="ERROR")
+            # Check for specific quota errors
+            if "quota" in str(e).lower():
+                return "API Error: You have exceeded your usage quota. Please check your plan and billing details."
+            return f"API Error: {e}"
+
+# Create a single, shared instance of the client to be used by all modules
+gemini_client = GeminiClient()

src/utils/logger.py

@@ -0,0 +1,20 @@
+# src/utils/logger.py
+# A simple, centralized logging utility for Project Chimera.
+
+import datetime
+import config
+
+def log(source, message, level="INFO", header=False):
+    """
+    A centralized logging function.
+    - source: The component of the system generating the log (e.g., "CRC", "SFE").
+    - message: The log message.
+    - level: The severity of the message (e.g., "INFO", "WARN", "ERROR").
+    - header: If True, prints a decorative header for major events.
+    """
+    if config.OPERATION_MODE == 'development' or level != "INFO":
+        timestamp = datetime.datetime.now().strftime("%H:%M:%S")
+        if header:
+            print(f"\n{'='*20} {message} {'='*20}")
+        else:
+            print(f"[{timestamp} | {source:<20} | {level:<5}] {message}")