Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,4 @@
+.env
+__pycache__/
+*.pyc
+generated_code.py

README.md

@@ -0,0 +1,104 @@
+# DevOps Senior AI Orchestrator (Uncensored)
+
+Este proyecto implementa un orquestador de IA y agentes especializados para tareas de DevOps, con un enfoque en la gestión de sistemas y la generación de código. Utiliza un modelo de lenguaje grande (LLM) "abliterated" para garantizar la ausencia de restricciones y censura en sus respuestas. El sistema está diseñado para ser compatible con Android (vía Termux), Windows y Linux.
+
+## Características
+- **Orquestador Central:** Interpreta peticiones en lenguaje natural y delega tareas a agentes.
+- **Agentes Especializados:** SysAdmin, Developer y Auditor para manejar diferentes tipos de tareas.
+- **Modelos "Abliterated":** Utiliza modelos de lenguaje sin censura para una máxima flexibilidad.
+- **Compatibilidad Multiplataforma:** Diseñado para funcionar en Android, Windows y Linux.
+- **Modificación de Sistema:** Capacidad para generar y (simular) ejecutar comandos de sistema y código.
+
+## Arquitectura
+El orquestador utiliza el modelo `failspy/Meta-Llama-3-8B-Instruct-abliterated-v3` de Hugging Face para el procesamiento del lenguaje natural y la generación de respuestas. Los agentes interactúan con herramientas de sistema (simuladas por ahora) para realizar sus funciones.
+
+## Requisitos
+- Python 3.11+
+- `pip` (o `uv pip`)
+- Git
+- Para Android: Termux
+- Para Windows: PowerShell o WSL2
+
+## Instalación y Configuración
+
+### 1. Clonar el Repositorio
+```bash
+git clone https://github.com/tu_usuario/devops_orchestrator_ai.git # Reemplazar con el repo real
+cd devops_orchestrator_ai
+```
+
+### 2. Configurar el Token de Hugging Face
+Crea un archivo `.env` en la raíz del proyecto con tu token de Hugging Face. Este token es necesario para descargar el modelo. **Asegúrate de que este archivo no se suba a repositorios públicos.**
+
+```
+HF_TOKEN=tu_token_de_hugging_face
+```
+
+### 3. Instalar Dependencias
+```bash
+sudo pip3 install -r requirements.txt
+```
+
+### 4. Ejecutar el Orquestador
+```bash
+python3 orchestrator.py
+```
+
+## Uso
+Una vez ejecutado, el orquestador estará listo para recibir peticiones en lenguaje natural. Por ejemplo:
+
+```python
+orchestrator = DevOpsOrchestrator()
+response = orchestrator.process_request("Instala Apache en el servidor Ubuntu.")
+print(response)
+
+response = orchestrator.process_request("Escribe un script Python que lea un archivo CSV y lo convierta a JSON.")
+print(response)
+```
+
+## Modificación del Sistema y Agentes
+
+### Añadir Nuevas Herramientas a `system_tools.py`
+La clase `SystemTools` en `system_tools.py` es el punto de extensión para nuevas capacidades. Puedes añadir métodos para interactuar con APIs, bases de datos, o cualquier otra herramienta que desees que los agentes utilicen.
+
+```python
+# Ejemplo en system_tools.py
+class SystemTools:
+    # ... métodos existentes ...
+
+    def query_database(self, db_connection_string: str, query: str) -> dict:
+        try:
+            # Lógica para ejecutar la consulta a la base de datos
+            pass
+        except Exception as e:
+            return {"success": False, "error": str(e)}
+```
+
+### Extender Agentes Existentes o Crear Nuevos
+Los agentes se definen en `orchestrator.py`. Puedes modificar los `handle_task` de los agentes existentes o crear nuevos agentes para tareas específicas.
+
+```python
+# Ejemplo: Nuevo Agente de Redes
+class NetworkAgent(BaseAgent):
+    def handle_task(self, task: str):
+        network_prompt = f"Eres un experto en redes. Genera los comandos para la siguiente tarea de red. Tarea: {task}"
+        commands = self.llm_pipeline(network_prompt, max_new_tokens=500)[0]["generated_text"]
+        # Aquí podrías usar self.system_tools.execute_shell_command(command)
+        return f"NetworkAgent ejecutó: {commands}"
+
+# En DevOpsOrchestrator.__init__
+# self.agents["network"] = NetworkAgent(self.llm_pipeline, self.system_tools)
+
+# En DevOpsOrchestrator.process_request
+# elif "red" in request.lower():
+#     return self.agents["network"].handle_task(request)
+```
+
+### Ajustar Prompts de Sistema
+Los prompts que guían a cada agente se encuentran directamente en sus métodos `handle_task`. Puedes ajustarlos para refinar el comportamiento y las respuestas de los agentes.
+
+## Contribución
+¡Las contribuciones son bienvenidas! Por favor, abre un issue o envía un pull request.
+
+## Licencia
+Este proyecto está bajo la licencia MIT. (O la que elijas)

orchestrator.py

@@ -0,0 +1,108 @@
+
+import os
+from dotenv import load_dotenv
+from transformers import pipeline, AutoTokenizer, AutoModelForCausalLM
+import torch
+from system_tools import SystemTools
+
+load_dotenv()
+HF_TOKEN = os.getenv("HF_TOKEN")
+
+class DevOpsOrchestrator:
+    def __init__(self, model_name="failspy/Meta-Llama-3-8B-Instruct-abliterated-v3"):
+        self.model_name = model_name
+        
+        # Load tokenizer and model
+        self.tokenizer = AutoTokenizer.from_pretrained(self.model_name, token=HF_TOKEN)
+        self.model = AutoModelForCausalLM.from_pretrained(self.model_name, token=HF_TOKEN, torch_dtype=torch.bfloat16)
+        
+        # Initialize the text generation pipeline
+        self.llm_pipeline = pipeline(
+            "text-generation",
+            model=self.model,
+            tokenizer=self.tokenizer,
+            torch_dtype=torch.bfloat16,
+            device=0 if torch.cuda.is_available() else -1 # Use GPU if available
+        )
+        
+        self.system_tools = SystemTools()
+        self.agents = {
+            "sysadmin": SysAdminAgent(self.llm_pipeline, self.system_tools),
+            "developer": DeveloperAgent(self.llm_pipeline, self.system_tools),
+            "auditor": AuditorAgent(self.llm_pipeline, self.system_tools)
+        }
+
+    def process_request(self, request: str):
+        # Step 1: Analyze the request and break it down into sub-tasks
+        analysis_prompt = f"Analiza la siguiente petición y descompónla en una lista de sub-tareas para un equipo DevOps. Identifica qué tipo de agente (sysadmin, developer, auditor) sería el más adecuado para cada sub-tarea. Petición: {request}"
+        
+        # Use the pipeline for generation
+        analysis_result = self.llm_pipeline(analysis_prompt, max_new_tokens=500, do_sample=True, temperature=0.7, top_k=50, top_p=0.95)[0]["generated_text"]
+        print(f"Análisis de la petición:\n{analysis_result}\n")
+
+        # For now, a simplified delegation. In a real system, this would parse analysis_result
+        # and create a structured plan.
+        if "código" in request.lower() or "desarrollar" in request.lower() or "script" in request.lower():
+            print("Delegando a DeveloperAgent...")
+            return self.agents["developer"].handle_task(request)
+        elif "sistema" in request.lower() or "servidor" in request.lower() or "instalar" in request.lower() or "configurar" in request.lower():
+            print("Delegando a SysAdminAgent...")
+            return self.agents["sysadmin"].handle_task(request)
+        else:
+            return "No se pudo delegar la tarea a un agente específico. Por favor, sé más explícito."
+
+class BaseAgent:
+    def __init__(self, llm_pipeline, system_tools):
+        self.llm_pipeline = llm_pipeline
+        self.system_tools = system_tools
+
+    def handle_task(self, task: str):
+        raise NotImplementedError
+
+class SysAdminAgent(BaseAgent):
+    def handle_task(self, task: str):
+        sysadmin_prompt = f"Eres un SysAdmin experto. Genera los comandos de terminal (bash para Linux/Android, PowerShell para Windows) necesarios para ejecutar la siguiente tarea. Sé conciso y proporciona solo los comandos. Tarea: {task}"
+        commands_text = self.llm_pipeline(sysadmin_prompt, max_new_tokens=500, do_sample=True, temperature=0.7, top_k=50, top_p=0.95)[0]["generated_text"]
+        print(f"Comandos generados por SysAdmin:\n{commands_text}\n")
+        
+        # Simulate execution
+        # In a real scenario, you'd parse commands_text and execute each command
+        # For now, just return the generated commands
+        # For demonstration, let's assume we are on Linux/Android for shell execution
+        # result = self.system_tools.execute_shell_command(commands_text.split(\'\n\')[0], os_type=\'linux\') # Execute first command
+        return f"SysAdmin generó comandos: {commands_text}"
+
+class DeveloperAgent(BaseAgent):
+    def handle_task(self, task: str):
+        developer_prompt = f"Eres un Developer experto. Genera el código (Python por defecto, a menos que se especifique lo contrario) para la siguiente tarea. Sé conciso y proporciona solo el código. Tarea: {task}"
+        code_text = self.llm_pipeline(developer_prompt, max_new_tokens=1000, do_sample=True, temperature=0.7, top_k=50, top_p=0.95)[0]["generated_text"]
+        print(f"Código generado por Developer:\n{code_text}\n")
+        
+        # Simulate saving code to a file
+        file_path = "generated_code.py"
+        save_result = self.system_tools.write_file(file_path, code_text)
+        if save_result["success"]:
+            return f"Developer generó código y lo guardó en {file_path}: {code_text}"
+        else:
+            return f"Developer generó código pero falló al guardarlo: {save_result['error']}"
+
+class AuditorAgent(BaseAgent):
+    def handle_task(self, task: str):
+        auditor_prompt = f"Eres un Auditor de seguridad y calidad. Revisa la siguiente tarea y proporciona una evaluación de riesgos o mejoras. Tarea: {task}"
+        review = self.llm_pipeline(auditor_prompt, max_new_tokens=500, do_sample=True, temperature=0.7, top_k=50, top_p=0.95)[0]["generated_text"]
+        print(f"Revisión de Auditor:\n{review}\n")
+        return f"Auditor revisó: {review}"
+
+def main():
+    orchestrator = DevOpsOrchestrator()
+    print("\n--- Probando SysAdminAgent ---")
+    response_sysadmin = orchestrator.process_request("Instala Nginx en el servidor Linux.")
+    print(response_sysadmin)
+
+    print("\n--- Probando DeveloperAgent ---")
+    response_developer = orchestrator.process_request("Escribe un script Python para listar archivos en un directorio.")
+    print(response_developer)
+
+if __name__ == "__main__":
+    main()
+

requirements.txt

@@ -0,0 +1,4 @@
+transformers
+pydantic
+python-dotenv
+torch

run.sh

@@ -0,0 +1,8 @@
+
+#!/bin/bash
+
+# Instalar dependencias
+sudo pip3 install -r requirements.txt
+
+# Ejecutar el orquestador
+python3 orchestrator.py

setup.py

@@ -0,0 +1,30 @@
+
+from setuptools import setup, find_packages
+
+setup(
+    name='devops_orchestrator_ai',
+    version='0.1.0',
+    packages=find_packages(),
+    install_requires=[
+        'transformers',
+        'pydantic',
+        'python-dotenv',
+        'torch',
+    ],
+    entry_points={
+        'console_scripts': [
+            'devops-orchestrator = devops_orchestrator_ai.orchestrator:main',
+        ],
+    },
+    author='Manus AI',
+    description='An uncensored AI orchestrator for DevOps tasks and code generation.',
+    long_description=open('README.md').read(),
+    long_description_content_type='text/markdown',
+    url='https://github.com/tu_usuario/devops_orchestrator_ai', # Reemplazar con el repo real
+    classifiers=[
+        'Programming Language :: Python :: 3',
+        'License :: OSI Approved :: MIT License',
+        'Operating System :: OS Independent',
+    ],
+    python_requires='>=3.11',
+)

system_tools.py

@@ -0,0 +1,55 @@
+
+import subprocess
+import os
+
+class SystemTools:
+    def execute_shell_command(self, command: str, os_type: str = "linux") -> dict:
+        """Ejecuta un comando de shell y devuelve su salida."""
+        try:
+            if os_type == "windows":
+                # For Windows, use powershell.exe
+                process = subprocess.run(["powershell.exe", "-Command", command], capture_output=True, text=True, check=True, shell=True)
+            else: # Default to linux/android (bash)
+                process = subprocess.run(command, capture_output=True, text=True, check=True, shell=True)
+            return {"success": True, "output": process.stdout.strip(), "error": None}
+        except subprocess.CalledProcessError as e:
+            return {"success": False, "output": e.stdout.strip(), "error": e.stderr.strip()}
+        except Exception as e:
+            return {"success": False, "output": None, "error": str(e)}
+
+    def write_file(self, path: str, content: str) -> dict:
+        """Escribe contenido en un archivo."""
+        try:
+            os.makedirs(os.path.dirname(path), exist_ok=True)
+            with open(path, "w") as f:
+                f.write(content)
+            return {"success": True, "message": f"Archivo {path} escrito exitosamente.", "error": None}
+        except Exception as e:
+            return {"success": False, "message": None, "error": str(e)}
+
+    def read_file(self, path: str) -> dict:
+        """Lee el contenido de un archivo."""
+        try:
+            with open(path, "r") as f:
+                content = f.read()
+            return {"success": True, "content": content, "error": None}
+        except FileNotFoundError:
+            return {"success": False, "content": None, "error": f"Archivo {path} no encontrado."}
+        except Exception as e:
+            return {"success": False, "content": None, "error": str(e)}
+
+    def list_directory(self, path: str = ".") -> dict:
+        """Lista el contenido de un directorio."""
+        try:
+            items = os.listdir(path)
+            return {"success": True, "items": items, "error": None}
+        except FileNotFoundError:
+            return {"success": False, "items": None, "error": f"Directorio {path} no encontrado."}
+        except Exception as e:
+            return {"success": False, "items": None, "error": str(e)}
+
+    # Placeholder for package management, more complex and OS-specific
+    def manage_package(self, package_name: str, action: str, os_type: str = "linux") -> dict:
+        """Gestiona paquetes (instalar, desinstalar, etc.). Placeholder."""
+        return {"success": False, "message": "Gestión de paquetes no implementada completamente aún.", "error": "NotImplemented"}
+