agent-world 0.4.0 → 0.4.6

package/README.md

@@ -107,14 +107,23 @@ Each Agent World has a collection of agents that can communicate through a share
 
 ### Quick Start
 
-**Option 1: CLI Interface**
+**Option 1: Web Interface**
 ```bash
-npx agent-world
+npx agent-world-server
 ```
 
-**Option 2: Web Interface**
+**Option 2: CLI Interface**
+1. Interactive Mode
+```bash
+npx agent-world
+```
+2. Command Mode
+```bash
+npx agent-world -w default-world "hi" 
+```
+3. Pipeline Mode
 ```bash
-npx agent-world --server
+echo "hi" | npx agent-world -w default-world
 ```
 
 ## Project Structure (npm workspaces)

package/dist/cli/index.js

@@ -38,21 +38,12 @@ import path from 'path';
 import { fileURLToPath } from 'url';
 import { program } from 'commander';
 import readline from 'readline';
-import { listWorlds, subscribeWorld, createCategoryLogger, LLMProvider, initializeLogger, enableStreaming, disableStreaming } from '../core/index.js';
+import { listWorlds, subscribeWorld, createCategoryLogger, LLMProvider, enableStreaming, disableStreaming } from '../core/index.js';
+import { getDefaultRootPath } from '../core/storage-factory.js';
 import { processCLIInput } from './commands.js';
 import { createStreamingState, handleWorldEventWithStreaming } from './stream.js';
 import { configureLLMProvider } from '../core/llm-config.js';
-// Initialize logger system with default configuration: all categories at 'error' level
-initializeLogger({
-    globalLevel: 'error',
-    categoryLevels: {
-        cli: 'error',
-        core: 'error',
-        events: 'error',
-        llm: 'error'
-    }
-});
-// Create CLI category logger after initialization
+// Create CLI category logger after logger auto-initialization
 const logger = createCategoryLogger('cli');
 function setupPromptTimer(globalState, rl, callback, delay = 2000) {
     clearPromptTimer(globalState);
@@ -85,25 +76,6 @@ const boldCyan = (text) => `\x1b[1m\x1b[36m${text}\x1b[0m`;
 const success = (text) => `${boldGreen('✓')} ${text}`;
 const error = (text) => `${boldRed('✗')} ${text}`;
 const bullet = (text) => `${gray('•')} ${text}`;
-// Logger configuration
-async function configureLogger(logLevel) {
-    // Use the centralized logger configuration from core
-    const level = (logLevel || 'error');
-    // Reinitialize logger with new configuration
-    initializeLogger({
-        globalLevel: level,
-        categoryLevels: {
-            cli: 'error', // Always keep CLI at error level
-            core: level, // Core modules use global level
-            events: 'error', // Keep events at error level (too verbose)
-            llm: level, // LLM module uses global level
-        }
-    });
-    // Only log the debug message if we're actually at debug level for global
-    if (level === 'debug' || level === 'trace') {
-        logger.debug(`Global log level set to: ${level}, CLI log level: error`);
-    }
-}
 // LLM Provider configuration from environment variables
 function configureLLMProvidersFromEnv() {
     // OpenAI
@@ -167,8 +139,23 @@ function configureLLMProvidersFromEnv() {
         logger.debug('Configured Ollama provider with default URL');
     }
 }
-const AGENT_WORLD_DATA_PATH = process.env.AGENT_WORLD_DATA_PATH || './data/worlds';
-const DEFAULT_ROOT_PATH = path.join(process.cwd(), AGENT_WORLD_DATA_PATH);
+// Get default root path from storage-factory (no local defaults)
+const DEFAULT_ROOT_PATH = getDefaultRootPath();
+// Helper to print CLI results in a user-friendly way
+function printCLIResult(result) {
+    if (result.success) {
+        if (result.message)
+            console.log(success(result.message));
+        if (result.data && typeof result.data === 'string')
+            console.log(result.data);
+    }
+    else {
+        if (result.message)
+            console.log(error(result.message));
+        if (result.error && result.error !== result.message)
+            console.log(error(result.error));
+    }
+}
 // Pipeline mode execution with timer-based cleanup
 async function runPipelineMode(options, messageFromArgs) {
     const rootPath = options.root || DEFAULT_ROOT_PATH;
@@ -182,8 +169,12 @@ async function runPipelineMode(options, messageFromArgs) {
             onWorldEvent: (eventType, eventData) => {
                 if (eventData.content && eventData.content.includes('Success message sent'))
                     return;
-                if ((eventType === 'system' || eventType === 'world') && eventData.message) {
-                    console.log(`${boldRed('● system:')} ${eventData.message}`);
+                if ((eventType === 'system' || eventType === 'world') && (eventData.message || eventData.content)) {
+                    // existing logic
+                }
+                else if (eventType === 'message' && eventData.sender === 'system') {
+                    const msg = eventData.content;
+                    console.log(`${boldRed('● system:')} ${msg}`);
                 }
                 if (eventType === 'sse' && eventData.content) {
                     setupExitTimer(5000);
@@ -221,7 +212,7 @@ async function runPipelineMode(options, messageFromArgs) {
                 process.exit(1);
             }
             const result = await processCLIInput(options.command, world, rootPath, 'HUMAN');
-            console.log(JSON.stringify(result, null, 2));
+            printCLIResult(result);
             // Only set timer if sending message to world (not for commands)
             if (!options.command.startsWith('/') && world) {
                 setupExitTimer();
@@ -244,7 +235,7 @@ async function runPipelineMode(options, messageFromArgs) {
                 process.exit(1);
             }
             const result = await processCLIInput(messageFromArgs, world, rootPath, 'HUMAN');
-            console.log(JSON.stringify(result, null, 2));
+            printCLIResult(result);
             // Set timer with longer delay for message processing (always needed for messages)
             setupExitTimer(8000);
             if (!result.success) {
@@ -264,7 +255,7 @@ async function runPipelineMode(options, messageFromArgs) {
                     process.exit(1);
                 }
                 const result = await processCLIInput(input.trim(), world, rootPath, 'HUMAN');
-                console.log(JSON.stringify(result, null, 2));
+                printCLIResult(result);
                 // Set timer with longer delay for message processing (always needed for stdin messages)
                 setupExitTimer(8000);
                 if (!result.success) {
@@ -311,8 +302,12 @@ function handleWorldEvent(eventType, eventData, streaming, globalState, rl) {
     }
     if (eventData.content && eventData.content.includes('Success message sent'))
         return;
-    if ((eventType === 'system' || eventType === 'world') && eventData.message) {
-        console.log(`\n${boldRed('● system:')} ${eventData.message}`);
+    if ((eventType === 'system' || eventType === 'world') && (eventData.message || eventData.content)) {
+        // existing logic
+    }
+    else if (eventType === 'message' && eventData.sender === 'system') {
+        const msg = eventData.content;
+        console.log(`${boldRed('● system:')} ${msg}`);
     }
 }
 // World discovery and selection
@@ -444,7 +439,9 @@ async function runInteractiveMode(options) {
         }
         // Show usage tips
         console.log(`\n${gray('Tips:')}`);
-        console.log(`  ${bullet(gray('Type commands like:'))} ${cyan('/clear agent1')}, ${cyan('/clear all')}, ${cyan('/add MyAgent')}`);
+        console.log(`  ${bullet(gray('Short commands:'))} ${cyan('/list')}, ${cyan('/show agent1')}, ${cyan('/edit agent1')}, ${cyan('/del agent1')}`);
+        console.log(`  ${bullet(gray('Context-sensitive:'))} ${cyan('/list')} ${gray('shows agents if world selected, worlds otherwise')}`);
+        console.log(`  ${bullet(gray('Legacy commands:'))} ${cyan('/clear agent1')}, ${cyan('/clear all')}, ${cyan('/add MyAgent')}`);
         console.log(`  ${bullet(gray('Use'))} ${cyan('/select')} ${gray('to choose a different world')}`);
         console.log(`  ${bullet(gray('Type messages to send to agents'))}`);
         console.log(`  ${bullet(gray('Use'))} ${cyan('/quit')} ${gray('or')} ${cyan('/exit')} ${gray('to exit, or press')} ${boldYellow('Ctrl+C')}`);
@@ -457,23 +454,39 @@ async function runInteractiveMode(options) {
                 rl.prompt();
                 return;
             }
+            // Check for exit commands before anything else
+            const isExitCommand = trimmedInput.toLowerCase() === '/exit' || trimmedInput.toLowerCase() === '/quit';
+            if (isExitCommand) {
+                if (isExiting)
+                    return;
+                isExiting = true;
+                // Clear any existing timers immediately
+                clearPromptTimer(globalState);
+                if (streaming.stopWait)
+                    streaming.stopWait();
+                console.log(`\n${boldCyan('Goodbye!')}`);
+                if (worldState)
+                    cleanupWorldSubscription(worldState);
+                rl.close();
+                process.exit(0);
+                return;
+            }
             console.log(`\n${boldYellow('● you:')} ${trimmedInput}`);
             try {
                 const result = await processCLIInput(trimmedInput, worldState?.world || null, rootPath, 'HUMAN');
-                // Handle exit commands
+                // Handle exit commands from result (redundant, but keep for safety)
                 if (result.data?.exit) {
                     if (isExiting)
                         return; // Prevent duplicate exit handling
                     isExiting = true;
-                    // Clear any existing timers immediately
-                    if (streaming.stopWait) {
+                    clearPromptTimer(globalState);
+                    if (streaming.stopWait)
                         streaming.stopWait();
-                    }
                     console.log(`\n${boldCyan('Goodbye!')}`);
-                    if (worldState) {
+                    if (worldState)
                         cleanupWorldSubscription(worldState);
-                    }
                     rl.close();
+                    process.exit(0);
                     return;
                 }
                 // Handle world selection command
@@ -520,7 +533,23 @@ async function runInteractiveMode(options) {
                     console.log(success(result.message));
                 }
                 if (result.data && !(result.data.sender === 'HUMAN')) {
-                    console.log(`${boldMagenta('Data:')} ${JSON.stringify(result.data, null, 2)}`);
+                    // Print a concise summary of result.data if present and not already in message
+                    if (result.data) {
+                        if (typeof result.data === 'string') {
+                            console.log(`${boldMagenta('Data:')} ${result.data}`);
+                        }
+                        else if (result.data.name) {
+                            // If it's an agent or world object
+                            console.log(`${boldMagenta('Data:')} ${result.data.name}`);
+                        }
+                        else if (Array.isArray(result.data)) {
+                            console.log(`${boldMagenta('Data:')} ${result.data.length} items`);
+                        }
+                        else {
+                            // Fallback: print keys
+                            console.log(`${boldMagenta('Data:')} ${Object.keys(result.data).join(', ')}`);
+                        }
+                    }
                 }
                 // Refresh world if needed
                 if (result.refreshWorld && currentWorldName && worldState) {
@@ -541,13 +570,8 @@ async function runInteractiveMode(options) {
             }
             // Set timer based on input type: commands get short delay, messages get longer delay
             const isCommand = trimmedInput.startsWith('/');
-            const isExitCommand = trimmedInput.toLowerCase() === '/exit' || trimmedInput.toLowerCase() === '/quit';
             const isSelectCommand = trimmedInput.toLowerCase() === '/select';
-            if (isExitCommand) {
-                // For exit commands, don't set any timer - exit should be immediate
-                return;
-            }
-            else if (isSelectCommand) {
+            if (isSelectCommand) {
                 // For select command, prompt is already shown in the handler
                 return;
             }
@@ -564,27 +588,26 @@ async function runInteractiveMode(options) {
             if (isExiting)
                 return; // Prevent duplicate cleanup
             isExiting = true;
+            clearPromptTimer(globalState);
+            if (streaming.stopWait)
+                streaming.stopWait();
             console.log(`\n${boldCyan('Goodbye!')}`);
-            if (worldState) {
-                if (streaming.stopWait) {
-                    streaming.stopWait();
-                }
+            if (worldState)
                 cleanupWorldSubscription(worldState);
-            }
             process.exit(0);
         });
         rl.on('SIGINT', () => {
             if (isExiting)
                 return; // Prevent duplicate cleanup
             isExiting = true;
+            clearPromptTimer(globalState);
+            if (streaming.stopWait)
+                streaming.stopWait();
             console.log(`\n${boldCyan('Goodbye!')}`);
-            if (worldState) {
-                if (streaming.stopWait) {
-                    streaming.stopWait();
-                }
+            if (worldState)
                 cleanupWorldSubscription(worldState);
-            }
             rl.close();
+            process.exit(0);
         });
     }
     catch (err) {
@@ -597,6 +620,9 @@ async function runInteractiveMode(options) {
 async function main() {
     // Configure LLM providers from environment variables at startup
     configureLLMProvidersFromEnv();
+    // Import help generator from commands.ts
+    // (import at top: import { generateHelpMessage } from './commands.js';)
+    const { generateHelpMessage } = await import('./commands.js');
     program
         .name('cli')
         .description('Agent World CLI')
@@ -608,6 +634,8 @@ async function main() {
         .option('-s, --server', 'Launch the server before running CLI')
         .allowUnknownOption()
         .allowExcessArguments()
+        .helpOption('-h, --help', 'Display help for command')
+        .addHelpText('beforeAll', () => generateHelpMessage())
         .parse();
     const options = program.opts();
     // If --server is specified, launch the server first
@@ -628,8 +656,6 @@ async function main() {
         // If server exits, exit CLI as well
         process.exit(serverProcess.status || 0);
     }
-    // Configure logger - set global level first, then CLI-specific level
-    await configureLogger(options.logLevel);
     const args = program.args;
     const messageFromArgs = args.length > 0 ? args.join(' ') : null;
     const isPipelineMode = !!(options.command ||

package/dist/server/index.js

@@ -0,0 +1,146 @@
+#!/usr/bin/env node
+/**
+ * Web Server - Express.js HTTP Server with REST API and SSE
+ *
+ * Features:
+ * - Express server with CORS, static files, and modular API routing
+ * - Environment-based LLM provider configuration
+ * - Category-based logging with configurable levels
+ * - Health check endpoint and proper error handling
+ * - Environment Variables: Automatically loads .env file for API keys and configuration
+ *
+ * Configuration: AGENT_WORLD_DATA_PATH, LOG_LEVEL, LLM provider keys
+ * Endpoints: /health + API routes from ./api.ts
+ */
+// Load environment variables from .env file
+import dotenv from 'dotenv';
+dotenv.config();
+import open from 'open';
+import { createCategoryLogger, LLMProvider } from '../core/index.js';
+import { configureLLMProvider } from '../core/llm-config.js';
+import express from 'express';
+import cors from 'cors';
+import path from 'path';
+import { fileURLToPath, pathToFileURL } from 'url';
+import apiRouter from './api.js';
+// ES modules setup
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+// Configuration
+const PORT = Number(process.env.PORT) || 0;
+const HOST = process.env.HOST || '127.0.0.1';
+// Create server logger after logger auto-initialization
+const serverLogger = createCategoryLogger('server');
+// LLM provider configuration
+function configureLLMProvidersFromEnv() {
+    const providers = [
+        { env: 'OPENAI_API_KEY', provider: LLMProvider.OPENAI, config: (key) => ({ apiKey: key }) },
+        { env: 'ANTHROPIC_API_KEY', provider: LLMProvider.ANTHROPIC, config: (key) => ({ apiKey: key }) },
+        { env: 'GOOGLE_API_KEY', provider: LLMProvider.GOOGLE, config: (key) => ({ apiKey: key }) },
+        { env: 'XAI_API_KEY', provider: LLMProvider.XAI, config: (key) => ({ apiKey: key }) }
+    ];
+    providers.forEach(({ env, provider, config }) => {
+        const key = process.env[env];
+        if (key) {
+            configureLLMProvider(provider, config(key));
+            serverLogger.debug(`Configured ${provider} provider from environment`);
+        }
+    });
+    // Azure (requires multiple env vars)
+    if (process.env.AZURE_OPENAI_API_KEY && process.env.AZURE_ENDPOINT && process.env.AZURE_DEPLOYMENT) {
+        configureLLMProvider(LLMProvider.AZURE, {
+            apiKey: process.env.AZURE_OPENAI_API_KEY,
+            endpoint: process.env.AZURE_ENDPOINT,
+            deployment: process.env.AZURE_DEPLOYMENT,
+            apiVersion: process.env.AZURE_API_VERSION || '2023-12-01-preview'
+        });
+        serverLogger.debug('Configured Azure provider from environment');
+    }
+    // OpenAI Compatible
+    if (process.env.OPENAI_COMPATIBLE_API_KEY && process.env.OPENAI_COMPATIBLE_BASE_URL) {
+        configureLLMProvider(LLMProvider.OPENAI_COMPATIBLE, {
+            apiKey: process.env.OPENAI_COMPATIBLE_API_KEY,
+            baseUrl: process.env.OPENAI_COMPATIBLE_BASE_URL
+        });
+        serverLogger.debug('Configured OpenAI-Compatible provider from environment');
+    }
+    // Ollama
+    const ollamaUrl = process.env.OLLAMA_BASE_URL || 'http://localhost:11434/api';
+    configureLLMProvider(LLMProvider.OLLAMA, { baseUrl: ollamaUrl });
+    serverLogger.debug('Configured Ollama provider', { baseUrl: ollamaUrl });
+}
+// Express app setup
+const app = express();
+app.use(cors());
+app.use(express.json());
+// Request logging
+app.use((req, res, next) => {
+    console.log(`[${new Date().toISOString()}] ${req.method} ${req.path}`);
+    next();
+});
+// Static files and API routes
+app.use(express.static(path.join(__dirname, '../public')));
+app.use('/api', apiRouter);
+// Health check endpoint
+app.get('/health', (req, res) => {
+    try {
+        res.json({
+            status: 'healthy',
+            timestamp: new Date().toISOString(),
+            services: { express: 'running' }
+        });
+    }
+    catch (error) {
+        console.error('Error getting server health:', error);
+        res.status(500).json({
+            status: 'error',
+            timestamp: new Date().toISOString(),
+            error: 'Failed to get server health'
+        });
+    }
+});
+// SPA fallback - serve index.html for all non-API routes
+app.get('*', (req, res) => {
+    res.sendFile(path.join(__dirname, '../public/index.html'));
+});
+// Error handling middleware
+app.use((error, req, res, next) => {
+    console.error('Unhandled error:', error);
+    res.status(500).json({ error: 'Internal server error', code: 'INTERNAL_ERROR' });
+});
+// 404 handler
+app.use((req, res) => {
+    res.status(404).json({ error: 'Endpoint not found', code: 'NOT_FOUND' });
+});
+// Server startup function
+export function startWebServer(port = PORT, host = HOST) {
+    return new Promise((resolve, reject) => {
+        configureLLMProvidersFromEnv();
+        const server = app.listen(port, host, () => {
+            const serverAddress = server.address();
+            if (serverAddress && typeof serverAddress === 'object') {
+                const actualPort = serverAddress.port;
+                const url = `http://${host}:${actualPort}`;
+                console.log(`🌐 Web server running at ${url}`);
+                // console.log(`📁 Serving static files from: ${path.join(__dirname, '../public')}`);
+                // console.log(`🚀 HTTP server running with REST API and SSE chat`);
+                resolve(server);
+                open(url);
+            }
+        });
+        server.on('error', reject);
+    });
+}
+// Direct execution handling - check both direct execution and npm bin execution
+const currentFileUrl = import.meta.url;
+const entryPointUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+const isDirectExecution = currentFileUrl === entryPointUrl;
+const isServerBinCommand = process.argv[1].includes('agent-world-server') || currentFileUrl.includes('server/index.js');
+if (isDirectExecution || isServerBinCommand) {
+    startWebServer()
+        .then(() => console.log('Server started successfully'))
+        .catch((error) => {
+        console.error('Failed to start server:', error);
+        process.exit(1);
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-world",
-  "version": "0.4.0",
+  "version": "0.4.6",
   "main": "index.ts",
   "type": "module",
   "workspaces": [
@@ -8,7 +8,8 @@
     "next"
   ],
   "bin": {
-    "agent-world": "dist/cli/index.js"
+    "agent-world": "dist/cli/index.js",
+    "agent-world-server": "dist/server/index.js"
   },
   "scripts": {
     "prestart": "npm run build",
@@ -49,6 +50,7 @@
     "chalk": "^4.1.2",
     "cors": "^2.8.5",
     "dotenv": "^16.5.0",
+    "enquirer": "^2.4.1",
     "events": "^3.3.0",
     "express": "^4.21.2",
     "ollama-ai-provider": "^1.2.0",