neuroagent 1.3.0

package/neuroagent/tools/code_executor.py

@@ -0,0 +1,69 @@
+import subprocess
+import tempfile
+import os
+from typing import Dict, Any
+from neuroagent.tools.base import Tool
+
+
+class CodeExecutorTool(Tool):
+    def __init__(self):
+        super().__init__(
+            name="code_executor",
+            description="Execute Python or JavaScript code. Input: code string. Output: execution result."
+        )
+    
+    async def execute(self, code: str, language: str = "python") -> Dict[str, Any]:
+        try:
+            if language == "python":
+                return await self._execute_python(code)
+            elif language == "javascript":
+                return await self._execute_javascript(code)
+            else:
+                return {"error": f"Unsupported language: {language}"}
+        except Exception as e:
+            return {"error": str(e), "output": None}
+    
+    async def _execute_python(self, code: str) -> Dict[str, Any]:
+        import asyncio
+        
+        def run_code():
+            output = []
+            errors = []
+            
+            try:
+                compiled = compile(code, "<string>", "exec")
+                exec_globals = {}
+                exec(compiled, exec_globals)
+                
+                for key, value in exec_globals.items():
+                    if not key.startswith("_"):
+                        output.append(f"{key} = {repr(value)}")
+                
+                return {"output": "\n".join(output) if output else "Code executed successfully", "error": None}
+            except Exception as e:
+                return {"output": None, "error": str(e)}
+        
+        return await asyncio.to_thread(run_code)
+    
+    async def _execute_javascript(self, code: str) -> Dict[str, Any]:
+        try:
+            import aiohttp
+            url = "https://api.jdoodle.com/v1/execute"
+            payload = {
+                "script": code,
+                "language": "nodejs",
+                "versionIndex": 0
+            }
+            
+            async with aiohttp.ClientSession() as session:
+                async with session.post(url, json=payload) as response:
+                    data = await response.json()
+                    return {"output": data.get("output", ""), "error": data.get("error")}
+        except Exception as e:
+            return {"output": None, "error": str(e)}
+
+
+def code_executor(code: str, language: str = "python") -> Dict[str, Any]:
+    import asyncio
+    tool = CodeExecutorTool()
+    return asyncio.run(tool.execute(code, language))

package/neuroagent/tools/file_manager.py

@@ -0,0 +1,62 @@
+import os
+from typing import Dict, Any, Optional, List
+from pathlib import Path
+from neuroagent.tools.base import Tool
+
+
+class FileManagerTool(Tool):
+    def __init__(self, base_path: Optional[str] = None):
+        super().__init__(
+            name="file_manager",
+            description="Create, read, update, delete files. Actions: read, write, list, delete."
+        )
+        self.base_path = Path(base_path or os.getcwd())
+    
+    async def execute(self, action: str, path: str = "", content: str = "") -> Dict[str, Any]:
+        try:
+            file_path = self.base_path / path
+            
+            if action == "read":
+                if not file_path.exists():
+                    return {"error": f"File not found: {path}"}
+                with open(file_path, "r", encoding="utf-8") as f:
+                    return {"content": f.read(), "path": path}
+            
+            elif action == "write":
+                file_path.parent.mkdir(parents=True, exist_ok=True)
+                with open(file_path, "w", encoding="utf-8") as f:
+                    f.write(content)
+                return {"success": True, "path": path}
+            
+            elif action == "list":
+                if not file_path.exists():
+                    return {"error": f"Directory not found: {path}"}
+                items = []
+                for item in file_path.iterdir():
+                    items.append({
+                        "name": item.name,
+                        "type": "directory" if item.is_dir() else "file"
+                    })
+                return {"items": items, "path": path}
+            
+            elif action == "delete":
+                if not file_path.exists():
+                    return {"error": f"Path not found: {path}"}
+                if file_path.is_file():
+                    file_path.unlink()
+                else:
+                    import shutil
+                    shutil.rmtree(file_path)
+                return {"success": True, "path": path}
+            
+            else:
+                return {"error": f"Unknown action: {action}"}
+        
+        except Exception as e:
+            return {"error": str(e)}
+
+
+def file_manager(action: str, path: str = "", content: str = "") -> Dict[str, Any]:
+    import asyncio
+    tool = FileManagerTool()
+    return asyncio.run(tool.execute(action, path, content))

package/neuroagent/tools/http_client.py

@@ -0,0 +1,57 @@
+import aiohttp
+from typing import Dict, Any, Optional
+from neuroagent.tools.base import Tool
+
+
+class HTTPClientTool(Tool):
+    def __init__(self):
+        super().__init__(
+            name="http_client",
+            description="Make HTTP requests (GET, POST, PUT, DELETE). Input: url, method, headers, body."
+        )
+    
+    async def execute(
+        self,
+        url: str,
+        method: str = "GET",
+        headers: Optional[Dict[str, str]] = None,
+        body: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, Any]:
+        try:
+            headers = headers or {"Content-Type": "application/json"}
+            
+            async with aiohttp.ClientSession() as session:
+                async with session.request(
+                    method=method.upper(),
+                    url=url,
+                    headers=headers,
+                    json=body if body and method in ["POST", "PUT", "PATCH"] else None
+                ) as response:
+                    content = await response.text()
+                    try:
+                        json_data = await response.json()
+                        return {
+                            "status": response.status,
+                            "headers": dict(response.headers),
+                            "body": json_data
+                        }
+                    except:
+                        return {
+                            "status": response.status,
+                            "headers": dict(response.headers),
+                            "body": content
+                        }
+        
+        except Exception as e:
+            return {"error": str(e)}
+
+
+def http_client(
+    url: str,
+    method: str = "GET",
+    headers: Optional[Dict[str, str]] = None,
+    body: Optional[Dict[str, Any]] = None
+) -> Dict[str, Any]:
+    import asyncio
+    tool = HTTPClientTool()
+    return asyncio.run(tool.execute(url, method, headers, body))

package/neuroagent/tools/web_search.py

@@ -0,0 +1,48 @@
+import aiohttp
+from typing import Dict, Any, Optional
+from neuroagent.tools.base import Tool
+
+
+class WebSearchTool(Tool):
+    def __init__(self, api_key: Optional[str] = None):
+        super().__init__(
+            name="web_search",
+            description="Search the web for information. Input: query string. Output: search results."
+        )
+        self.api_key = api_key
+    
+    async def execute(self, query: str, num_results: int = 5) -> Dict[str, Any]:
+        try:
+            import os
+            search_api = os.getenv("SEARCH_API", "ddg")
+            
+            if search_api == "ddg":
+                url = "https://api.duckduckgo.com/"
+                params = {
+                    "q": query,
+                    "format": "json",
+                    "no_html": 1,
+                    "skip_disambig": 1
+                }
+                async with aiohttp.ClientSession() as session:
+                    async with session.get(url, params=params) as response:
+                        data = await response.json()
+                        results = []
+                        for item in data.get("RelatedTopics", [])[:num_results]:
+                            if "Text" in item:
+                                results.append({
+                                    "title": item.get("Text", "").split(" - ")[0] if " - " in item.get("Text", "") else item.get("Text", ""),
+                                    "url": item.get("URL", ""),
+                                    "snippet": item.get("Text", "")
+                                })
+                        return {"results": results, "query": query}
+            else:
+                return {"error": "Search API not configured"}
+        except Exception as e:
+            return {"error": str(e)}
+
+
+def web_search(query: str, num_results: int = 5) -> Dict[str, Any]:
+    import asyncio
+    tool = WebSearchTool()
+    return asyncio.run(tool.execute(query, num_results))

package/neuroagent/utils/__init__.py

@@ -0,0 +1,3 @@
+from neuroagent.utils.helpers import get_env, require_env, format_response, parse_json_safe
+
+__all__ = ["get_env", "require_env", "format_response", "parse_json_safe"]

package/neuroagent/utils/helpers.py

@@ -0,0 +1,31 @@
+import os
+from typing import Optional
+from dotenv import load_dotenv
+
+
+load_dotenv()
+
+
+def get_env(key: str, default: Optional[str] = None) -> Optional[str]:
+    return os.getenv(key, default)
+
+
+def require_env(key: str) -> str:
+    value = os.getenv(key)
+    if not value:
+        raise EnvironmentError(f"Required environment variable '{key}' is not set")
+    return value
+
+
+def format_response(content: str, max_length: int = 2000) -> str:
+    if len(content) <= max_length:
+        return content
+    return content[:max_length] + "..."
+
+
+def parse_json_safe(text: str):
+    import json
+    try:
+        return json.loads(text)
+    except json.JSONDecodeError:
+        return None

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "neuroagent",
+  "version": "1.3.0",
+  "description": "NeuroAgent - Build intelligent AI agents in minutes. A modern framework for creating AI agents with tools, memory, and multi-agent teams.",
+  "private": false,
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "src",
+    "neuroagent",
+    "web_example",
+    "server.js",
+    "setup.py",
+    "requirements.txt",
+    "README.md",
+    "LICENSE",
+    "package.json"
+  ],
+  "scripts": {
+    "build": "node scripts/build.js",
+    "prepublishOnly": "npm run build",
+    "start-server": "node server.js",
+    "install-deps": "pip install -r requirements.txt",
+    "postinstall": "echo 'To install Python dependencies, run: pip install -r requirements.txt'"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/neuroagent/neuroagent.git"
+  },
+  "keywords": [
+    "ai",
+    "agent",
+    "framework",
+    "gpt",
+    "openai",
+    "llm",
+    "chatbot",
+    "widget",
+    "chat",
+    "multi-agent",
+    "autogpt",
+    "crewai",
+    "langchain"
+  ],
+  "author": "NeuroAgent Team",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/neuroagent/neuroagent/issues"
+  },
+  "homepage": "https://neuroagent.ai",
+  "engines": {
+    "node": ">=14.0.0"
+  }
+}

package/requirements.txt

@@ -0,0 +1,15 @@
+fastapi>=0.104.0
+uvicorn>=0.24.0
+pydantic>=2.5.0
+openai>=1.3.0
+anthropic>=0.18.0
+python-dotenv>=1.0.0
+aiohttp>=3.9.0
+websockets>=12.0
+numpy>=1.24.0
+scikit-learn>=1.3.0
+chromadb>=0.4.0
+tiktoken>=0.5.0
+rich>=13.7.0
+click>=8.1.0
+httpx>=0.25.0

package/setup.py

@@ -0,0 +1,61 @@
+from setuptools import setup, find_packages
+
+setup(
+    name="neuroagent",
+    version="0.2.0",
+    description="Modern AI Agent Framework - Create intelligent AI agents with few lines of code",
+    long_description=open("README.md", encoding="utf-8").read(),
+    long_description_content_type="text/markdown",
+    author="NeuroAgent Team",
+    author_email="team@neuroagent.ai",
+    url="https://github.com/neuroagent/neuroagent",
+    project_urls={
+        "Bug Tracker": "https://github.com/neuroagent/neuroagent/issues",
+        "Documentation": "https://docs.neuroagent.ai",
+        "Source Code": "https://github.com/neuroagent/neuroagent",
+    },
+    packages=find_packages(exclude=["examples", "tests"]),
+    include_package_data=True,
+    install_requires=[
+        "fastapi>=0.104.0",
+        "uvicorn>=0.24.0",
+        "pydantic>=2.5.0",
+        "openai>=1.3.0",
+        "anthropic>=0.18.0",
+        "python-dotenv>=1.0.0",
+        "aiohttp>=3.9.0",
+        "websockets>=12.0",
+        "numpy>=1.24.0",
+        "rich>=13.7.0",
+        "click>=8.1.0",
+        "httpx>=0.25.0",
+    ],
+    extras_require={
+        "dev": [
+            "pytest>=7.4.0",
+            "pytest-asyncio>=0.21.0",
+            "pytest-cov>=4.1.0",
+            "black>=23.0.0",
+            "ruff>=0.1.0",
+            "mypy>=1.5.0",
+        ],
+    },
+    entry_points={
+        "console_scripts": [
+            "neuroagent=neuroagent.cli.neuroagent_cli:main",
+        ],
+    },
+    python_requires=">=3.10",
+    classifiers=[
+        "Development Status :: 3 - Alpha",
+        "Intended Audience :: Developers",
+        "Topic :: Software Development :: Libraries :: Application Frameworks",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.10",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3.12",
+        "Operating System :: OS Independent",
+    ],
+    keywords="ai agent gpt openai llm chatbot multi-agent",
+)

package/src/index.d.ts

@@ -0,0 +1,55 @@
+export interface NeuroAgentConfig {
+    apiUrl?: string;
+    agent?: string;
+    apiKey?: string;
+    theme?: 'light' | 'dark';
+    position?: 'bottom-right' | 'bottom-left' | 'top-right' | 'top-left';
+    title?: string;
+    welcomeMessage?: string;
+}
+
+export interface ChatResponse {
+    response: string;
+    agent: string;
+}
+
+export interface AgentList {
+    agents: string[];
+}
+
+export interface AgentRequest {
+    name: string;
+    goal: string;
+    model?: string;
+    apiKey?: string;
+    enablePlanning?: boolean;
+    tools?: string[];
+}
+
+export declare class NeuroAgentClient {
+    constructor(config: NeuroAgentConfig);
+    chat(message: string): Promise<ChatResponse>;
+    run(task: string): Promise<ChatResponse>;
+    createAgent(config: AgentRequest): Promise<any>;
+    listAgents(): Promise<AgentList>;
+    onWebSocket(event: 'open' | 'message' | 'error' | 'close', callback: (data?: any) => void): WebSocket;
+}
+
+export declare class NeuroAgentWidget {
+    constructor(config: NeuroAgentConfig);
+    open(): void;
+    close(): void;
+    toggle(): void;
+}
+
+export interface NeuroAgentInit {
+    init(config: NeuroAgentConfig): NeuroAgentWidget;
+}
+
+declare const NeuroAgent: {
+    init(config: NeuroAgentConfig): NeuroAgentWidget;
+    Client: typeof NeuroAgentClient;
+    Widget: typeof NeuroAgentWidget;
+};
+
+export default NeuroAgent;

package/src/index.js

@@ -0,0 +1,215 @@
+/**
+ * NeuroAgent - Modern AI Agent Framework
+ * JavaScript/TypeScript Client
+ */
+
+const API_URL = 'http://localhost:8000';
+
+class NeuroAgentClient {
+    constructor(config = {}) {
+        this.apiUrl = config.apiUrl || API_URL;
+        this.agent = config.agent || 'default';
+        this.apiKey = config.apiKey || null;
+    }
+
+    async request(endpoint, data) {
+        const headers = {
+            'Content-Type': 'application/json'
+        };
+        
+        if (this.apiKey) {
+            headers['Authorization'] = `Bearer ${this.apiKey}`;
+        }
+
+        const response = await fetch(`${this.apiUrl}${endpoint}`, {
+            method: 'POST',
+            headers,
+            body: JSON.stringify({
+                agent: this.agent,
+                ...data
+            })
+        });
+
+        return response.json();
+    }
+
+    async chat(message) {
+        return this.request('/agent/chat', { message });
+    }
+
+    async run(task) {
+        return this.request('/agent/run', { message: task });
+    }
+
+    async createAgent(config) {
+        const response = await fetch(`${this.apiUrl}/agents`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(config)
+        });
+        return response.json();
+    }
+
+    async listAgents() {
+        const response = await fetch(`${this.apiUrl}/agents`);
+        return response.json();
+    }
+
+    onWebSocket(event, callback) {
+        const ws = new WebSocket(`${this.apiUrl.replace('http', 'ws')}/ws/${this.agent}`);
+        
+        ws.onopen = () => {
+            if (event === 'open') callback();
+        };
+        
+        ws.onmessage = (e) => {
+            const data = JSON.parse(e.data);
+            if (event === 'message') callback(data);
+        };
+        
+        ws.onerror = (error) => {
+            if (event === 'error') callback(error);
+        };
+        
+        ws.onclose = () => {
+            if (event === 'close') callback();
+        };
+
+        return ws;
+    }
+}
+
+class NeuroAgentWidget {
+    constructor(config) {
+        this.client = new NeuroAgentClient(config);
+        this.config = {
+            theme: config.theme || 'dark',
+            position: config.position || 'bottom-right',
+            title: config.title || 'AI Assistant',
+            welcomeMessage: config.welcomeMessage || 'Hello! How can I help you?',
+            ...config
+        };
+        
+        this.isOpen = false;
+        this.init();
+    }
+
+    init() {
+        this.createStyles();
+        this.createWidget();
+        this.createChat();
+        this.bindEvents();
+    }
+
+    createStyles() {
+        if (document.getElementById('neuroagent-styles')) return;
+        
+        const styles = document.createElement('style');
+        styles.id = 'neuroagent-styles';
+        styles.textContent = `
+            .na-widget { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, sans-serif; position: fixed; z-index: 999999; }
+            .na-widget-btn { width: 60px; height: 60px; border-radius: 50%; background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); border: none; cursor: pointer; box-shadow: 0 4px 15px rgba(102,126,234,0.4); display: flex; align-items: center; justify-content: center; transition: transform 0.3s; }
+            .na-widget-btn:hover { transform: scale(1.1); }
+            .na-widget-btn svg { width: 30px; height: 30px; fill: white; }
+            .na-chat { position: fixed; width: 380px; height: 500px; background: white; border-radius: 16px; box-shadow: 0 10px 40px rgba(0,0,0,0.2); display: none; flex-direction: column; overflow: hidden; }
+            .na-chat.open { display: flex; }
+            .na-chat-header { background: linear-gradient(135deg, #667eea 0%, #764ba2 100%); color: white; padding: 16px; display: flex; align-items: center; justify-content: space-between; }
+            .na-chat-title { font-weight: 600; font-size: 16px; }
+            .na-chat-close { background: none; border: none; color: white; cursor: pointer; font-size: 20px; }
+            .na-messages { flex: 1; padding: 16px; overflow-y: auto; display: flex; flex-direction: column; gap: 12px; }
+            .na-msg { max-width: 80%; padding: 12px 16px; border-radius: 16px; font-size: 14px; line-height: 1.5; }
+            .na-msg.user { align-self: flex-end; background: #667eea; color: white; border-bottom-right-radius: 4px; }
+            .na-msg.assistant { align-self: flex-start; background: #f0f0f0; color: #333; border-bottom-left-radius: 4px; }
+            .na-msg.thinking { align-self: flex-start; background: #f0f0f0; color: #666; font-style: italic; }
+            .na-input-area { padding: 16px; border-top: 1px solid #eee; display: flex; gap: 8px; }
+            .na-input-area input { flex: 1; padding: 12px 16px; border: 1px solid #ddd; border-radius: 24px; outline: none; font-size: 14px; }
+            .na-input-area input:focus { border-color: #667eea; }
+            .na-input-area button { background: #667eea; color: white; border: none; padding: 12px 20px; border-radius: 24px; cursor: pointer; font-size: 14px; font-weight: 500; }
+            .na-input-area button:disabled { background: #ccc; cursor: not-allowed; }
+            .na-pos-bottom-right { bottom: 20px; right: 20px; }
+            .na-pos-bottom-left { bottom: 20px; left: 20px; }
+            .na-pos-top-right { top: 20px; right: 20px; }
+            .na-pos-top-left { top: 20px; left: 20px; }
+            .na-chat.na-pos-bottom-right, .na-chat.na-pos-bottom-left { bottom: 90px; }
+            .na-chat.na-pos-top-right, .na-chat.na-pos-top-left { top: 90px; }
+            .na-chat.na-pos-bottom-right, .na-chat.na-pos-top-right { right: 20px; }
+            .na-chat.na-pos-bottom-left, .na-chat.na-pos-top-left { left: 20px; }
+        `;
+        document.head.appendChild(styles);
+    }
+
+    createWidget() {
+        this.widget = document.createElement('div');
+        this.widget.className = `na-widget na-pos-${this.config.position}`;
+        this.widget.innerHTML = `
+            <button class="na-widget-btn" title="${this.config.title}">
+                <svg viewBox="0 0 24 24"><path d="M20 2H4c-1.1 0-2 .9-2 2v18l4-4h14c1.1 0 2-.9 2-2V4c0-1.1-.9-2-2-2zm0 14H6l-2 2V4h16v12z"/></svg>
+            </button>
+        `;
+        document.body.appendChild(this.widget);
+    }
+
+    createChat() {
+        this.chat = document.createElement('div');
+        this.chat.className = `na-chat na-pos-${this.config.position}`;
+        this.chat.innerHTML = `
+            <div class="na-chat-header">
+                <span class="na-chat-title">${this.config.title}</span>
+                <button class="na-chat-close">&times;</button>
+            </div>
+            <div class="na-messages"></div>
+            <div class="na-input-area">
+                <input type="text" placeholder="Type a message..." />
+                <button>Send</button>
+            </div>
+        `;
+        document.body.appendChild(this.chat);
+        this.messagesEl = this.chat.querySelector('.na-messages');
+        this.inputEl = this.chat.querySelector('input');
+        this.sendBtn = this.chat.querySelector('button');
+        this.addMessage(this.config.welcomeMessage, 'assistant');
+    }
+
+    bindEvents() {
+        this.widget.querySelector('.na-widget-btn').addEventListener('click', () => this.toggle());
+        this.chat.querySelector('.na-chat-close').addEventListener('click', () => this.close());
+        this.sendBtn.addEventListener('click', () => this.send());
+        this.inputEl.addEventListener('keypress', (e) => { if (e.key === 'Enter') this.send(); });
+    }
+
+    toggle() { this.isOpen ? this.close() : this.open(); }
+    open() { this.isOpen = true; this.chat.classList.add('open'); this.inputEl.focus(); }
+    close() { this.isOpen = false; this.chat.classList.remove('open'); }
+
+    addMessage(content, type = 'assistant') {
+        const msg = document.createElement('div');
+        msg.className = `na-msg ${type}`;
+        msg.textContent = content;
+        this.messagesEl.appendChild(msg);
+        this.messagesEl.scrollTop = this.messagesEl.scrollHeight;
+    }
+
+    async send() {
+        const msg = this.inputEl.value.trim();
+        if (!msg) return;
+        
+        this.inputEl.value = '';
+        this.addMessage(msg, 'user');
+        this.sendBtn.disabled = true;
+        this.addMessage('Thinking...', 'thinking');
+        
+        try {
+            const response = await this.client.chat(msg);
+            this.messagesEl.lastElementChild?.remove();
+            this.addMessage(response.response || 'No response', 'assistant');
+        } catch (error) {
+            this.messagesEl.lastElementChild?.remove();
+            this.addMessage('Error connecting to server', 'assistant');
+        }
+        
+        this.sendBtn.disabled = false;
+    }
+}
+
+module.exports = { NeuroAgentClient, NeuroAgentWidget };
+module.exports.default = { NeuroAgentClient, NeuroAgentWidget };