@sschepis/robodev 1.0.0

package/src/lib/README.md

@@ -0,0 +1,114 @@
+# AI Man Library Interface
+
+This module exposes the core AI Assistant capabilities as a structured library, allowing integration into other AI agents, tools, or applications.
+
+## Overview
+
+The `AiMan` class provides a high-level interface to the AI system. It supports:
+- **Dependency Injection**: Plug in your own LLM provider and status reporting mechanisms.
+- **Agent Integration**: Easily expose the system as a tool for other AI agents (e.g., LangChain, AutoGPT).
+- **Callback Statusing**: Receive real-time updates on progress, tool execution, and logs.
+
+## Usage
+
+### Basic Usage
+
+```javascript
+import { AiMan } from 'ai-assistant/lib';
+
+// Initialize with default settings (uses internal LLM and console output)
+const ai = new AiMan();
+
+// Execute a complex task
+const result = await ai.execute("Create a new feature for user authentication in the current project");
+
+console.log(result);
+```
+
+### Advanced Usage with Custom Adapters
+
+You can inject custom adapters to control how the AI communicates and reports status.
+
+```javascript
+import { AiMan } from 'ai-assistant/lib';
+
+// Custom LLM Adapter (must implement generateContent)
+const myLLMAdapter = {
+    async generateContent(request) {
+        // request follows OpenAI Chat Completion API format
+        // Call your own model service here...
+        return {
+            choices: [{
+                message: { role: 'assistant', content: '...' }
+            }]
+        };
+    }
+};
+
+// Custom Status Adapter (must implement log, onProgress, etc.)
+const myStatusAdapter = {
+    log(level, message, meta) {
+        // Send logs to your dashboard/frontend
+        socket.emit('log', { level, message, meta });
+    },
+    onProgress(percent, status) {
+        updateProgressBar(percent, status);
+    },
+    onToolStart(name, args) {
+        console.log(`Tool Started: ${name}`);
+    },
+    onToolEnd(name, result) {
+        console.log(`Tool Ended: ${name}`);
+    }
+};
+
+// Initialize with adapters
+const ai = new AiMan({
+    workingDir: '/path/to/project',
+    llmAdapter: myLLMAdapter,
+    statusAdapter: myStatusAdapter
+});
+
+await ai.execute("Refactor the login module");
+```
+
+## Agent Integration
+
+To use AI Man as a tool within another agent (e.g., a "Manager" agent delegating coding tasks), use `getToolDefinition()`:
+
+```javascript
+const aiMan = new AiMan();
+const toolDef = aiMan.getToolDefinition();
+
+// toolDef matches standard JSON Schema for function calling:
+// {
+//   "name": "execute_software_development_task",
+//   "description": "...",
+//   "parameters": { ... }
+// }
+
+// Register this tool with your primary agent
+myAgent.registerTool(toolDef, async (args) => {
+    return await aiMan.execute(args.task);
+});
+```
+
+## API Reference
+
+### `AiMan` Class
+
+#### `constructor(config)`
+- `config.workingDir`: Path to the project root (default: `process.cwd()`).
+- `config.llmAdapter`: Object implementing `LLMAdapter` interface.
+- `config.statusAdapter`: Object implementing `StatusAdapter` interface.
+- `config.overrides`: Optional configuration overrides (model, etc.).
+
+#### `async execute(task)`
+Executes the given natural language task. Returns a Promise resolving to the final output string.
+
+#### `getToolDefinition()`
+Returns a JSON Schema object describing the `execute` capability, suitable for LLM function calling.
+
+### Interfaces
+
+See `src/lib/interfaces.d.ts` for TypeScript definitions of `LLMAdapter` and `StatusAdapter`.

package/src/lib/adapters/console-status-adapter.mjs

@@ -0,0 +1,48 @@
+import { consoleStyler } from '../../ui/console-styler.mjs';
+
+/**
+ * Status Adapter that outputs to the console using consoleStyler
+ * This is the default behavior if no adapter is provided
+ */
+export class ConsoleStatusAdapter {
+  constructor() {}
+
+  /**
+   * Log a message
+   * @param {string} level - Log level/category
+   * @param {string} message - Message content
+   * @param {Object} [metadata] - Optional metadata
+   */
+  log(level, message, metadata = {}) {
+    consoleStyler.log(level, message, metadata);
+  }
+
+  /**
+   * Report progress
+   * @param {number} progress - 0-100
+   * @param {string} status - Status description
+   */
+  onProgress(progress, status) {
+    consoleStyler.log('progress', `[${progress}%] ${status}`);
+  }
+
+  /**
+   * Called when a tool starts
+   * @param {string} toolName 
+   * @param {Object} args 
+   */
+  onToolStart(toolName, args) {
+    // consoleStyler handles tool logging internally via logs typically, 
+    // but we can make it explicit here
+    // consoleStyler.log('working', `Executing tool: ${toolName}`);
+  }
+
+  /**
+   * Called when a tool ends
+   * @param {string} toolName 
+   * @param {any} result 
+   */
+  onToolEnd(toolName, result) {
+    // consoleStyler.log('tools', `✓ Tool completed: ${toolName}`);
+  }
+}

package/src/lib/adapters/network-llm-adapter.mjs

@@ -0,0 +1,37 @@
+import { callProvider, callProviderStream } from '../../core/ai-provider.mjs';
+
+/**
+ * Default LLM Adapter that uses the built-in network provider (OpenAI/Gemini/Local)
+ */
+export class NetworkLLMAdapter {
+  constructor(config = {}) {
+    this.config = config;
+  }
+
+  /**
+   * Call the LLM provider
+   * @param {Object} requestBody - OpenAI compatible request
+   * @returns {Promise<Object>} OpenAI compatible response
+   */
+  async generateContent(requestBody) {
+    // Merge config overrides if any
+    const finalRequest = {
+      ...requestBody,
+      ...this.config
+    };
+    return await callProvider(finalRequest);
+  }
+
+  /**
+   * Stream the LLM response
+   * @param {Object} requestBody 
+   * @returns {Promise<Response>} Fetch response or stream
+   */
+  async generateContentStream(requestBody) {
+    const finalRequest = {
+      ...requestBody,
+      ...this.config
+    };
+    return await callProviderStream(finalRequest);
+  }
+}

package/src/lib/index.mjs

@@ -0,0 +1,101 @@
+import { MiniAIAssistant } from '../core/ai-assistant.mjs';
+import { ConsoleStatusAdapter } from './adapters/console-status-adapter.mjs';
+import { NetworkLLMAdapter } from './adapters/network-llm-adapter.mjs';
+import { consoleStyler } from '../ui/console-styler.mjs';
+
+/**
+ * Main entry point for the AI Man Library.
+ * Provides a structured interface for integrating the AI system into other agents or applications.
+ */
+export class AiMan {
+    /**
+     * Create a new AI Man instance
+     * @param {Object} config - Configuration options
+     * @param {string} [config.workingDir] - Working directory (defaults to process.cwd())
+     * @param {Object} [config.llmAdapter] - Adapter for LLM calls (defaults to NetworkLLMAdapter)
+     * @param {Object} [config.statusAdapter] - Adapter for status/logging (defaults to ConsoleStatusAdapter)
+     * @param {Object} [config.overrides] - Overrides for internal components (model, temperature, etc.)
+     */
+    constructor(config = {}) {
+        this.workingDir = config.workingDir || process.cwd();
+        
+        // Initialize adapters
+        this.llmAdapter = config.llmAdapter || new NetworkLLMAdapter(config.overrides || {});
+        this.statusAdapter = config.statusAdapter || new ConsoleStatusAdapter();
+        
+        // Configure global logger redirect if a custom status adapter is provided
+        // This ensures that internal components using consoleStyler route logs through the adapter
+        if (config.statusAdapter) {
+             consoleStyler.setListener(this.statusAdapter);
+        }
+
+        // Initialize the core assistant with injected dependencies
+        this.assistant = new MiniAIAssistant(this.workingDir, {
+            llmAdapter: this.llmAdapter
+        });
+    }
+
+    /**
+     * Initialize the system (loads tools, manifests, etc.)
+     */
+    async initialize() {
+        await this.assistant.initializeCustomTools();
+    }
+
+    /**
+     * Execute a high-level task
+     * @param {string} task - The task description
+     * @returns {Promise<string>} The result of the task execution
+     */
+    async execute(task) {
+        // Ensure initialized
+        if (!this.assistant.customToolsLoaded) {
+            await this.initialize();
+        }
+        
+        this.statusAdapter.onToolStart('ai_man_execute', { task });
+        
+        try {
+            const result = await this.assistant.run(task);
+            this.statusAdapter.onToolEnd('ai_man_execute', result);
+            return result;
+        } catch (error) {
+            const errorMessage = `Execution failed: ${error.message}`;
+            this.statusAdapter.log('error', errorMessage);
+            throw error;
+        }
+    }
+
+    /**
+     * Get the tool definition for integrating this library as a tool in another agent
+     * @returns {Object} JSON Schema for the tool
+     */
+    getToolDefinition() {
+        return {
+            name: "execute_software_development_task",
+            description: "Execute a complex software development task using the AI Man system. Capable of planning, coding, debugging, and verifying software features.",
+            parameters: {
+                type: "object",
+                properties: {
+                    task: {
+                        type: "string",
+                        description: "The detailed description of the task to perform. Be specific about requirements."
+                    }
+                },
+                required: ["task"]
+            }
+        };
+    }
+    
+    /**
+     * Get the current status/context of the assistant
+     * @returns {Object} Context object
+     */
+    getContext() {
+        return this.assistant.getContext();
+    }
+}
+
+// Re-export adapters for convenience
+export { ConsoleStatusAdapter } from './adapters/console-status-adapter.mjs';
+export { NetworkLLMAdapter } from './adapters/network-llm-adapter.mjs';

package/src/lib/interfaces.d.ts

@@ -0,0 +1,98 @@
+/**
+ * Interface for the AI Man Library Configuration
+ */
+export interface AiManConfig {
+  /** The working directory for the project */
+  workingDir: string;
+  /** Adapter for the host LLM service */
+  llmAdapter?: LLMAdapter;
+  /** Adapter for status reporting */
+  statusAdapter?: StatusAdapter;
+  /** Optional overrides for internal components */
+  overrides?: {
+    model?: string;
+    temperature?: number;
+  };
+}
+
+/**
+ * Adapter interface for providing LLM capabilities
+ * Conforms to OpenAI-compatible request/response structure
+ */
+export interface LLMAdapter {
+  /**
+   * call the LLM provider
+   * @param requestBody The standard OpenAI chat completion request body
+   * @returns The standard OpenAI chat completion response
+   */
+  generateContent(requestBody: any): Promise<any>;
+
+  /**
+   * (Optional) Stream the LLM response
+   * @param requestBody The standard OpenAI chat completion request body
+   * @returns A stream or async iterable of content chunks
+   */
+  generateContentStream?(requestBody: any): AsyncIterable<string> | Promise<ReadableStream>;
+}
+
+/**
+ * Adapter interface for status reporting and logging
+ */
+export interface StatusAdapter {
+  /**
+   * Log a message from the system
+   * @param level The log level or category (e.g., 'info', 'error', 'step', 'thought')
+   * @param message The message content
+   * @param metadata Optional metadata
+   */
+  log(level: string, message: string, metadata?: any): void;
+
+  /**
+   * Report progress on a long-running operation
+   * @param progress 0-100 completion percentage
+   * @param status Current status description
+   */
+  onProgress(progress: number, status: string): void;
+
+  /**
+   * Called when a tool execution starts
+   * @param toolName Name of the tool
+   * @param args Tool arguments
+   */
+  onToolStart(toolName: string, args: any): void;
+
+  /**
+   * Called when a tool execution completes
+   * @param toolName Name of the tool
+   * @param result Tool result
+   */
+  onToolEnd(toolName: string, result: any): void;
+}
+
+/**
+ * The main interface for the library
+ */
+export interface AiManInterface {
+  /**
+   * Initialize the library
+   */
+  initialize(): Promise<void>;
+
+  /**
+   * Execute a high-level task
+   * @param taskDescription The user's request
+   * @returns The final result or confirmation
+   */
+  executeTask(taskDescription: string): Promise<string>;
+
+  /**
+   * Get the current status of the project/workspace
+   */
+  getProjectStatus(): Promise<any>;
+
+  /**
+   * Get the tool definition for integrating this library into an agent
+   * @returns JSON Schema for the tool
+   */
+  getToolDefinition(): object;
+}

package/src/main.mjs

@@ -0,0 +1,61 @@
+// Main entry point for the AI Assistant
+// Orchestrates CLI interface and AI assistant initialization
+
+import { MiniAIAssistant } from './core/ai-assistant.mjs';
+import { CLIInterface } from './cli/cli-interface.mjs';
+
+// Main execution function
+async function main() {
+    const cli = new CLIInterface();
+    
+    try {
+        // Set up signal handlers for graceful shutdown
+        cli.setupSignalHandlers();
+        
+        // Parse command line arguments
+        const { args, workingDir, isInteractive, userInput, resume } = cli.parseArguments();
+        
+        // Display startup information
+        cli.displayStartupInfo(workingDir);
+        
+        // Initialize AI assistant
+        const assistant = new MiniAIAssistant(workingDir);
+        
+        // Load custom tools before starting
+        await assistant.initializeCustomTools();
+
+        // Resume session if requested
+        if (resume) {
+            await assistant.loadSession('.ai-session');
+        }
+        
+        if (isInteractive) {
+            // Interactive mode
+            await cli.startInteractiveMode(assistant, workingDir);
+        } else {
+            // Single-shot mode
+            await cli.runSingleShot(assistant, userInput, workingDir);
+        }
+        
+    } catch (error) {
+        cli.displayError(error);
+        process.exit(1);
+    } finally {
+        cli.close();
+    }
+}
+
+// Handle module execution
+if (import.meta.url === `file://${process.argv[1]}`) {
+    main().catch(err => {
+        // Import consoleStyler for error display
+        import('./ui/console-styler.mjs').then(({ consoleStyler }) => {
+            consoleStyler.log('error', `An unexpected error occurred: ${err.message}`);
+        }).catch(() => {
+            console.error("\x1b[31mAn unexpected error occurred:\x1b[0m", err);
+        });
+        process.exit(1);
+    });
+}
+
+export { main };

package/src/package/package-manager.mjs

@@ -0,0 +1,223 @@
+// Package management utilities
+// Handles npm package installation with Node.js compatibility checks
+
+import { exec } from 'child_process';
+import util from 'util';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const execPromise = util.promisify(exec);
+
+export class PackageManager {
+    constructor() {
+        // Node.js v18 compatibility - packages with known issues
+        this.problematicPackages = [
+            'axios', 'undici', 'node-fetch', 'cheerio', 'jsdom',
+            'puppeteer', 'playwright', 'got', 'superagent', 'request'
+        ];
+        
+        this.nodeMajorVersion = parseInt(process.version.slice(1).split('.')[0]);
+    }
+
+    // Install a single npm package with compatibility checks
+    async installPackage(packageName) {
+        // Node.js compatibility check - proactively avoid packages with known issues
+        if (this.nodeMajorVersion < 20 && this.problematicPackages.includes(packageName)) {
+            consoleStyler.log('system', `Skipping ${packageName} - Node.js v${this.nodeMajorVersion} compatibility issue`);
+            consoleStyler.log('system', 'Will use built-in alternatives (fetch for HTTP, regex for HTML parsing)');
+            
+            // Throw a specific error that can be caught and handled
+            throw new Error(`COMPATIBILITY_SKIP: ${packageName} incompatible with Node.js v${this.nodeMajorVersion}`);
+        }
+        
+        // Check if package might have undici dependencies in Node.js v18
+        if (this.nodeMajorVersion < 20 && packageName.includes('fetch')) {
+            consoleStyler.log('warning', `Warning: ${packageName} may have Node.js v${this.nodeMajorVersion} compatibility issues`);
+            throw new Error(`COMPATIBILITY_SKIP: ${packageName} may be incompatible with Node.js v${this.nodeMajorVersion}`);
+        }
+        
+        try {
+            // Install in the script's directory
+            const __filename = fileURLToPath(import.meta.url);
+            const scriptDir = path.dirname(path.dirname(path.dirname(__filename))); // Go up two levels from src/package
+            const { stdout, stderr } = await execPromise(`cd "${scriptDir}" && npm install ${packageName}`);
+            
+            if (stderr) {
+                // Check stderr for undici/File errors
+                if (stderr.includes('File is not defined') || stderr.includes('undici')) {
+                    consoleStyler.log('system', `Node.js compatibility issue - skipping ${packageName}`);
+                    return;
+                }
+            }
+        } catch (error) {
+            // Don't log error for compatibility skips
+            if (!error.message.startsWith('COMPATIBILITY_SKIP:')) {
+                console.error(`\x1b[31m[SYSTEM] Failed to install package '${packageName}': ${error.message}\x1b[0m`);
+                
+                // Enhanced Node.js compatibility detection
+                if (error.message.includes('File is not defined') ||
+                    error.message.includes('undici') ||
+                    error.message.includes('webidl') ||
+                    error.stdout?.includes('File is not defined') ||
+                    error.stderr?.includes('File is not defined')) {
+                    console.log(`\x1b[33m[SYSTEM] Node.js v${this.nodeMajorVersion} compatibility issue detected with ${packageName}\x1b[0m`);
+                    console.log(`\x1b[33m[SYSTEM] Skipping ${packageName} - will use built-in alternatives (fetch, fs, etc.)\x1b[0m`);
+                    throw new Error(`COMPATIBILITY_SKIP: ${packageName} incompatible with Node.js v${this.nodeMajorVersion}`);
+                }
+            }
+            
+            throw error;
+        }
+    }
+
+    // Install multiple packages with error handling
+    async installPackages(packages) {
+        const skippedPackages = [];
+        const installedPackages = [];
+        const failedPackages = [];
+
+        // Helper function to handle single package installation
+        const processPackage = async (pkg) => {
+            try {
+                // First check if package is already available
+                await import(pkg);
+                installedPackages.push(pkg);
+            } catch (e) {
+                if (e.code === 'ERR_MODULE_NOT_FOUND') {
+                    try {
+                        await this.installPackage(pkg);
+                        // Verify the package is accessible after installation
+                        try {
+                            await import(pkg);
+                            installedPackages.push(pkg);
+                        } catch (e2) {
+                            try {
+                                const __filename = fileURLToPath(import.meta.url);
+                                const scriptDir = path.dirname(path.dirname(__filename));
+                                const modulePath = `file://${path.join(scriptDir, 'node_modules', pkg)}`;
+                                await import(modulePath);
+                                installedPackages.push(pkg);
+                            } catch (e3) {
+                                // For CommonJS modules, just ensure they're installed
+                                installedPackages.push(pkg);
+                            }
+                        }
+                    } catch (installError) {
+                        if (installError.message.startsWith('COMPATIBILITY_SKIP:')) {
+                            skippedPackages.push(pkg);
+                            consoleStyler.log('system', `Skipped ${pkg} - will need to use built-in alternatives`);
+                        } else {
+                            failedPackages.push({ package: pkg, error: installError.message });
+                        }
+                    }
+                } else {
+                    failedPackages.push({ package: pkg, error: e.message });
+                }
+            }
+        };
+
+        // Process packages in parallel batches of 3 to avoid overwhelming system
+        const BATCH_SIZE = 3;
+        for (let i = 0; i < packages.length; i += BATCH_SIZE) {
+            const batch = packages.slice(i, i + BATCH_SIZE);
+            await Promise.all(batch.map(pkg => processPackage(pkg)));
+        }
+
+        return {
+            installed: installedPackages,
+            skipped: skippedPackages,
+            failed: failedPackages
+        };
+    }
+
+    // Attempt to import a package with multiple strategies
+    async importPackage(packageName) {
+        try {
+            // Try direct import first
+            return await import(packageName);
+        } catch (e) {
+            if (e.code === 'ERR_MODULE_NOT_FOUND') {
+                try {
+                    // Try from script directory with file:// protocol
+                    const __filename = fileURLToPath(import.meta.url);
+                    const scriptDir = path.dirname(path.dirname(path.dirname(__filename)));
+                    const modulePath = `file://${path.join(scriptDir, 'node_modules', packageName)}`;
+                    return await import(modulePath);
+                } catch (e2) {
+                    try {
+                        // Try with require for CommonJS modules
+                        const { createRequire } = await import('module');
+                        const require = createRequire(import.meta.url);
+                        return { default: require(packageName) };
+                    } catch (e3) {
+                        throw e; // Re-throw original error
+                    }
+                }
+            } else {
+                throw e; // Re-throw other import errors
+            }
+        }
+    }
+
+    // Check if a package is problematic for the current Node.js version
+    isProblematicPackage(packageName) {
+        if (this.nodeMajorVersion < 20 && this.problematicPackages.includes(packageName)) {
+            return true;
+        }
+        
+        if (this.nodeMajorVersion < 20 && packageName.includes('fetch')) {
+            return true;
+        }
+        
+        return false;
+    }
+
+    // Get alternative suggestions for problematic packages
+    getAlternatives(packageName) {
+        const alternatives = {
+            'axios': 'Use built-in fetch() for HTTP requests',
+            'node-fetch': 'Use built-in fetch() for HTTP requests',
+            'cheerio': 'Use regex patterns or built-in string methods for HTML parsing',
+            'jsdom': 'Use regex patterns for simple HTML parsing',
+            'puppeteer': 'Consider using simpler HTTP requests with fetch()',
+            'playwright': 'Consider using simpler HTTP requests with fetch()',
+            'got': 'Use built-in fetch() for HTTP requests',
+            'superagent': 'Use built-in fetch() for HTTP requests',
+            'request': 'Use built-in fetch() for HTTP requests (request is deprecated)'
+        };
+
+        return alternatives[packageName] || 'Consider using built-in Node.js modules or simpler alternatives';
+    }
+
+    // Log package installation results
+    logInstallationResults(results) {
+        if (results.installed.length > 0) {
+            consoleStyler.log('packages', `✓ Installed/Available: ${results.installed.join(', ')}`);
+        }
+        
+        if (results.skipped.length > 0) {
+            consoleStyler.log('packages', `⚠ Skipped (compatibility): ${results.skipped.join(', ')}`);
+            consoleStyler.log('packages', 'Use built-in alternatives instead');
+        }
+        
+        if (results.failed.length > 0) {
+            consoleStyler.log('packages', '✗ Failed installations:', { box: true });
+            results.failed.forEach(({ package: pkg, error }) => {
+                consoleStyler.log('packages', `  - ${pkg}: ${error}`, { indent: true });
+            });
+        }
+    }
+
+    // Set up require function for CommonJS modules
+    async setupCommonJSRequire() {
+        const { createRequire } = await import('module');
+        const __filename = fileURLToPath(import.meta.url);
+        const scriptDir = path.dirname(path.dirname(path.dirname(__filename)));
+        const require = createRequire(path.join(scriptDir, 'package.json'));
+        
+        // Make require available globally
+        global.require = require;
+        
+        return require;
+    }
+}