ideaco 1.1.5

package/src/core/agent/cli-agent/backends/registry.js

@@ -0,0 +1,580 @@
+/**
+ * CLI Backend Registry - Core registry and utility functions
+ * 
+ * Manages all CLI backends (built-in + custom), providing detection, registration, and execution.
+ * Each CLI model's configuration is loaded from its own folder's config.js.
+ *
+ * Features:
+ * - Auto-detect installed CLIs
+ * - Per-agent independent memory files (no sharing)
+ * - Generic configuration with custom CLI support
+ * - Child process I/O monitoring
+ * - Seamless integration with existing Agent system
+ */
+import { existsSync, mkdirSync, writeFileSync, unlinkSync } from 'fs';
+import { tmpdir } from 'os';
+import path from 'path';
+import { exec, spawn } from 'child_process';
+import { promisify } from 'util';
+import { knowledgeManager } from '../../../employee/knowledge.js';
+
+// Import each CLI model's configuration
+import { claudeCodeConfig } from './claude-code/config.js';
+import { codexConfig } from './codex/config.js';
+import { codebuddyConfig } from './codebuddy/config.js';
+
+const execAsync = promisify(exec);
+
+/**
+ * CLI backend states
+ */
+export const CLIBackendState = {
+  DETECTED: 'detected',       // Detected as installed
+  NOT_FOUND: 'not_found',     // Not detected
+  CONFIGURED: 'configured',   // Configured
+  ERROR: 'error',             // Detection error
+};
+
+/**
+ * Built-in CLI backend configuration list
+ * Aggregated from each folder's config.js
+ */
+const BUILTIN_BACKENDS = [
+  claudeCodeConfig,
+  codexConfig,
+  codebuddyConfig,
+];
+
+/**
+ * Build Agent Memory file content
+ * Merges agent prompt, long-term memories, skills, knowledge base, etc. into markdown format
+ * 
+ * @param {object} agent - Agent instance
+ * @returns {string} Markdown-formatted memory file content
+ */
+export function buildAgentMemoryContent(agent) {
+  const lines = [];
+
+  lines.push(`# ${agent.name} - ${agent.role}`);
+  lines.push('');
+  lines.push('> This file is auto-generated by AI Enterprise. Do not edit manually.');
+  lines.push('');
+
+  // Role definition
+  lines.push('## Role & Identity');
+  lines.push('');
+  lines.push(agent.prompt);
+  lines.push('');
+
+  // Identity information
+  lines.push('## Personal Info');
+  lines.push('');
+  lines.push(`- **Name**: ${agent.name}`);
+  lines.push(`- **Role**: ${agent.role}`);
+  lines.push(`- **Gender**: ${agent.gender === 'female' ? 'Female' : 'Male'}`);
+  lines.push(`- **Age**: ${agent.age}`);
+  lines.push(`- **Signature**: ${agent.signature}`);
+  lines.push(`- **Skills**: ${agent.skills.join(', ')}`);
+  lines.push('');
+
+  // Personality traits
+  if (agent.personality) {
+    lines.push('## Personality');
+    lines.push('');
+    lines.push(`- **Trait**: ${agent.personality.trait}`);
+    lines.push(`- **Tone**: ${agent.personality.tone}`);
+    lines.push(`- **Quirk**: ${agent.personality.quirk}`);
+    lines.push('');
+  }
+
+  // Long-term memories
+  const longTermMemories = agent.memory.searchLongTerm();
+  if (longTermMemories.length > 0) {
+    lines.push('## Long-term Memories');
+    lines.push('');
+    const recent = longTermMemories.slice(-30);
+    recent.forEach(m => {
+      lines.push(`- [${m.category}] ${m.content}`);
+    });
+    lines.push('');
+  }
+
+  // Short-term memories
+  if (agent.memory.shortTerm.length > 0) {
+    lines.push('## Current Context (Short-term)');
+    lines.push('');
+    agent.memory.shortTerm.forEach(m => {
+      lines.push(`- ${m.content}`);
+    });
+    lines.push('');
+  }
+
+
+
+  // Knowledge base
+  try {
+    const kbPrompt = knowledgeManager.buildKnowledgePrompt(agent.id, agent.department);
+    if (kbPrompt) {
+      lines.push('## Knowledge Base');
+      lines.push('');
+      lines.push(kbPrompt);
+      lines.push('');
+    }
+  } catch {}
+
+  // Teamwork rules
+  lines.push('## Teamwork Rules');
+  lines.push('');
+  lines.push('- You are part of a team. Coordinate with colleagues when needed.');
+  lines.push('- When working in parallel, avoid duplicate work and share discoveries.');
+  lines.push('- Produce real, working code output. Do not just describe what you would do.');
+  lines.push('- Be efficient: plan all needed operations at once, minimize tool call rounds.');
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+/**
+ * Get shell command prefix for nvm environment
+ * Used to execute CLI commands under a specific Node version
+ * 
+ * @param {string|null} nodeVersion - Node version, e.g. '20'
+ * @returns {string} Shell command prefix
+ */
+function getNvmPrefix(nodeVersion) {
+  if (!nodeVersion) return '';
+  return `export NVM_DIR="$HOME/.nvm" && [ -s "$NVM_DIR/nvm.sh" ] && . "$NVM_DIR/nvm.sh" && nvm use ${nodeVersion} > /dev/null 2>&1 && `;
+}
+
+/**
+ * CLI Backend Registry - Manages all CLI backends
+ */
+export class CLIBackendRegistry {
+  constructor() {
+    /** @type {Map<string, {config: object, state: string, version: string|null, lastDetected: Date|null}>} */
+    this.backends = new Map();
+
+    // Register built-in backends
+    BUILTIN_BACKENDS.forEach(config => {
+      this.backends.set(config.id, {
+        config: { ...config },
+        state: CLIBackendState.NOT_FOUND,
+        version: null,
+        lastDetected: null,
+      });
+    });
+  }
+
+  /**
+   * Register a custom CLI backend
+   * @param {object} config - CLI configuration
+   */
+  register(config) {
+    if (!config.id || !config.execCommand) {
+      throw new Error('CLI backend config requires at least id and execCommand');
+    }
+    const fullConfig = {
+      id: config.id,
+      name: config.name || config.id,
+      description: config.description || '',
+      icon: config.icon || '🔧',
+      detectCommand: config.detectCommand || `${config.execCommand} --version`,
+      execCommand: config.execCommand,
+      execArgs: config.execArgs || ['-p', '{prompt}'],
+      interactiveArgs: config.interactiveArgs || [],
+      memoryDir: config.memoryDir || `.${config.id}`,
+      memoryFile: config.memoryFile || 'MEMORY.md',
+      memoryFormat: config.memoryFormat || 'markdown',
+      workingDirSupport: config.workingDirSupport !== false,
+      pipeMode: config.pipeMode || 'args',
+      outputMode: config.outputMode || 'stdout',
+      initCommand: config.initCommand || null,
+      customEnv: config.customEnv || {},
+      nvmNode: config.nvmNode || null,
+      builtin: false,
+    };
+
+    this.backends.set(fullConfig.id, {
+      config: fullConfig,
+      state: CLIBackendState.NOT_FOUND,
+      version: null,
+      lastDetected: null,
+    });
+
+    console.log(`🔧 CLI Backend registered: ${fullConfig.name} (${fullConfig.id})`);
+    return fullConfig;
+  }
+
+  /**
+   * Unregister a custom CLI backend
+   */
+  unregister(backendId) {
+    const backend = this.backends.get(backendId);
+    if (!backend) return false;
+    if (backend.config.builtin) {
+      throw new Error('Cannot unregister built-in CLI backends');
+    }
+    this.backends.delete(backendId);
+    return true;
+  }
+
+  /**
+   * Detect if a single CLI is installed
+   * @param {string} backendId
+   * @returns {Promise<{detected: boolean, version: string|null}>}
+   */
+  async detect(backendId) {
+    const backend = this.backends.get(backendId);
+    if (!backend) throw new Error(`CLI backend not found: ${backendId}`);
+
+    const { config } = backend;
+    const nvmPrefix = getNvmPrefix(config.nvmNode);
+    const detectCmd = nvmPrefix + config.detectCommand;
+
+    try {
+      const { stdout } = await execAsync(detectCmd, {
+        timeout: 10000,
+        shell: '/bin/bash',
+        env: { ...process.env, ...config.customEnv },
+      });
+      const version = stdout.trim().split('\n')[0];
+      backend.state = CLIBackendState.DETECTED;
+      backend.version = version;
+      backend.lastDetected = new Date();
+      console.log(`✅ CLI detected: ${config.name} (${version})`);
+      return { detected: true, version };
+    } catch (error) {
+      backend.state = CLIBackendState.NOT_FOUND;
+      backend.version = null;
+      backend.lastDetected = new Date();
+      return { detected: false, version: null };
+    }
+  }
+
+  /**
+   * Detect all registered CLIs
+   * @returns {Promise<object[]>} Detection results list
+   */
+  async detectAll() {
+    const results = [];
+    const promises = [...this.backends.keys()].map(async (id) => {
+      const result = await this.detect(id);
+      results.push({ id, ...result, name: this.backends.get(id).config.name });
+    });
+    await Promise.all(promises);
+    return results;
+  }
+
+  /**
+   * Get all available (detected) backends
+   */
+  getAvailableBackends() {
+    return [...this.backends.values()]
+      .filter(b => b.state === CLIBackendState.DETECTED || b.state === CLIBackendState.CONFIGURED)
+      .map(b => ({
+        id: b.config.id,
+        name: b.config.name,
+        description: b.config.description,
+        icon: b.config.icon,
+        version: b.version,
+        builtin: b.config.builtin,
+        state: b.state,
+      }));
+  }
+
+  /**
+   * List all backends with their states
+   */
+  listAll() {
+    return [...this.backends.values()].map(b => ({
+      id: b.config.id,
+      name: b.config.name,
+      description: b.config.description,
+      icon: b.config.icon,
+      rating: b.config.rating || 80,
+      version: b.version,
+      state: b.state,
+      builtin: b.config.builtin,
+      lastDetected: b.lastDetected,
+      nvmNode: b.config.nvmNode,
+      execCommand: b.config.execCommand,
+    }));
+  }
+
+  /**
+   * Write memory file for an Agent
+   * Creates the CLI's memory file under the Agent's working directory
+   * 
+   * @param {string} backendId - CLI backend ID
+   * @param {object} agent - Agent instance
+   * @param {string} workspaceDir - Agent's workspace directory
+   */
+  writeAgentMemory(backendId, agent, workspaceDir) {
+    const backend = this.backends.get(backendId);
+    if (!backend) throw new Error(`CLI backend not found: ${backendId}`);
+
+    const { config } = backend;
+    const memoryContent = buildAgentMemoryContent(agent);
+
+    const agentDir = path.join(workspaceDir, `_cli_${agent.id.slice(0, 8)}`);
+    const memDir = path.join(agentDir, config.memoryDir);
+
+    if (!existsSync(memDir)) {
+      mkdirSync(memDir, { recursive: true });
+    }
+
+    const memFilePath = path.join(memDir, config.memoryFile);
+    writeFileSync(memFilePath, memoryContent, 'utf-8');
+
+    console.log(`📝 CLI memory written: ${config.name} -> ${memFilePath}`);
+    return { agentDir, memFilePath };
+  }
+
+  /**
+   * Execute a task via CLI
+   * Core method: executes the Agent's task through a CLI subprocess
+   * 
+   * @param {string} backendId - CLI backend ID
+   * @param {object} agent - Agent instance
+   * @param {object} task - Task description { title, description, context, requirements }
+   * @param {string} workspaceDir - Workspace directory
+   * @param {object} callbacks - Callbacks { onOutput, onError, onComplete }
+   * @param {object} options - Optional parameters { timeout }
+   * @returns {Promise<{output: string, exitCode: number, duration: number}>}
+   */
+  async executeTask(backendId, agent, task, workspaceDir, callbacks = {}, options = {}) {
+    const backend = this.backends.get(backendId);
+    if (!backend) throw new Error(`CLI backend not found: ${backendId}`);
+    if (backend.state !== CLIBackendState.DETECTED && backend.state !== CLIBackendState.CONFIGURED) {
+      throw new Error(`CLI backend ${backendId} is not available (state: ${backend.state})`);
+    }
+
+    const { config } = backend;
+
+    // 1. Write memory file
+    const { agentDir } = this.writeAgentMemory(backendId, agent, workspaceDir);
+
+    // 2. Build prompt
+    const prompt = this._buildTaskPrompt(task);
+
+    // 3. Build command-line arguments
+    const hasPromptPlaceholder = config.execArgs.some(arg => arg.includes('{prompt}'));
+    const isNvmMode = !!config.nvmNode;
+    const useStdin = !hasPromptPlaceholder || isNvmMode;
+    const args = isNvmMode
+      ? config.execArgs.filter(arg => arg !== '{prompt}').map(arg => arg.replace('{prompt}', ''))
+      : config.execArgs.map(arg => arg.replace('{prompt}', prompt));
+
+    // 4. Build execution environment (per-agent isolated XDG dirs to prevent CLI memory sharing)
+    const agentConfigDir = path.join(agentDir, '.config');
+    const agentDataDir = path.join(agentDir, '.local', 'share');
+    const agentStateDir = path.join(agentDir, '.local', 'state');
+    const agentCacheDir = path.join(agentDir, '.cache');
+    for (const dir of [agentConfigDir, agentDataDir, agentStateDir, agentCacheDir]) {
+      if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+    }
+    const env = {
+      ...process.env,
+      ...config.customEnv,
+      XDG_CONFIG_HOME: agentConfigDir,
+      XDG_DATA_HOME: agentDataDir,
+      XDG_STATE_HOME: agentStateDir,
+      XDG_CACHE_HOME: agentCacheDir,
+    };
+    const cwd = workspaceDir;
+
+    // 5. Ensure working directory exists
+    if (!existsSync(cwd)) {
+      mkdirSync(cwd, { recursive: true });
+    }
+
+    const timeoutMs = options.timeout || 600000;
+    const inactivityTimeoutMs = options.inactivityTimeout || 120000;
+
+    const promptMode = useStdin ? 'stdin' : 'args';
+    console.log(`🚀 CLI executing: ${config.execCommand} (${promptMode} prompt, ${Math.round(timeoutMs/1000)}s timeout, ${Math.round(inactivityTimeoutMs/1000)}s inactivity limit)`);
+    console.log(`   Working dir: ${cwd}`);
+    console.log(`   Prompt length: ${prompt.length} chars, mode: ${promptMode}`);
+
+    const startTime = Date.now();
+
+    return new Promise((resolve, reject) => {
+      let output = '';
+      let errorOutput = '';
+      let lastActivityTime = Date.now();
+      let totalTimer = null;
+      let inactivityTimer = null;
+      let killed = false;
+
+      const killChild = (reason) => {
+        if (killed) return;
+        killed = true;
+        const elapsed = Date.now() - startTime;
+        console.warn(`⏰ CLI killed: ${config.name} — ${reason} (after ${Math.round(elapsed/1000)}s)`);
+        try { child.kill('SIGTERM'); } catch {}
+        setTimeout(() => {
+          try { child.kill('SIGKILL'); } catch {}
+        }, 5000);
+      };
+
+      const resetInactivityTimer = () => {
+        lastActivityTime = Date.now();
+        if (inactivityTimer) clearTimeout(inactivityTimer);
+        inactivityTimer = setTimeout(() => {
+          killChild(`no output for ${Math.round(inactivityTimeoutMs/1000)}s`);
+        }, inactivityTimeoutMs);
+      };
+
+      let child;
+      const nvmPrefix = getNvmPrefix(config.nvmNode);
+
+      let promptTmpFile = null;
+      if (useStdin && isNvmMode) {
+        promptTmpFile = path.join(tmpdir(), `ai-ent-prompt-${Date.now()}-${Math.random().toString(36).slice(2)}.txt`);
+        writeFileSync(promptTmpFile, prompt, 'utf-8');
+      }
+
+      if (nvmPrefix) {
+        const argsStr = args.filter(a => a.length > 0).map(a => `'${a.replace(/'/g, "'\\''")}'`).join(' ');
+        const stdinPipe = promptTmpFile ? `cat '${promptTmpFile}' | ` : '';
+        const fullCommand = `${nvmPrefix}${stdinPipe}${config.execCommand} ${argsStr}`;
+        child = spawn('bash', ['-c', fullCommand], {
+          cwd,
+          env,
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+      } else {
+        child = spawn(config.execCommand, args, {
+          cwd,
+          env,
+          stdio: ['pipe', 'pipe', 'pipe'],
+        });
+      }
+
+      totalTimer = setTimeout(() => {
+        killChild(`total timeout ${Math.round(timeoutMs/1000)}s reached`);
+      }, timeoutMs);
+
+      resetInactivityTimer();
+
+      if (useStdin && !isNvmMode) {
+        child.stdin.write(prompt);
+      }
+      child.stdin.end();
+
+      child.stdout.on('data', (data) => {
+        const chunk = data.toString();
+        output += chunk;
+        resetInactivityTimer();
+        if (callbacks.onOutput) {
+          try { callbacks.onOutput(chunk); } catch {}
+        }
+      });
+
+      child.stderr.on('data', (data) => {
+        const chunk = data.toString();
+        errorOutput += chunk;
+        resetInactivityTimer();
+        if (callbacks.onError) {
+          try { callbacks.onError(chunk); } catch {}
+        }
+      });
+
+      child.on('close', (code) => {
+        if (totalTimer) clearTimeout(totalTimer);
+        if (inactivityTimer) clearTimeout(inactivityTimer);
+        if (promptTmpFile) { try { unlinkSync(promptTmpFile); } catch {} }
+
+        const duration = Date.now() - startTime;
+        const result = {
+          output: output.trim(),
+          errorOutput: errorOutput.trim(),
+          exitCode: killed ? (code ?? -1) : code,
+          duration,
+          backendId: config.id,
+          backendName: config.name,
+          killed,
+        };
+
+        console.log(`✅ CLI completed: ${config.name}, exit code ${code}${killed ? ' (killed)' : ''}, ${duration}ms`);
+
+        if (callbacks.onComplete) {
+          try { callbacks.onComplete(result); } catch {}
+        }
+
+        resolve(result);
+      });
+
+      child.on('error', (error) => {
+        if (totalTimer) clearTimeout(totalTimer);
+        if (inactivityTimer) clearTimeout(inactivityTimer);
+        if (promptTmpFile) { try { unlinkSync(promptTmpFile); } catch {} }
+
+        const duration = Date.now() - startTime;
+        console.error(`❌ CLI error: ${config.name} - ${error.message}`);
+        reject({
+          output: output.trim(),
+          errorOutput: error.message,
+          exitCode: -1,
+          duration,
+          backendId: config.id,
+          backendName: config.name,
+          error: error.message,
+          killed,
+        });
+      });
+    });
+  }
+
+  /**
+   * Build the task prompt (complete instructions for the CLI)
+   */
+  _buildTaskPrompt(task) {
+    let prompt = `Please complete the following task:\n\n`;
+    prompt += `**Task**: ${task.title}\n`;
+    if (task.description) {
+      prompt += `**Description**: ${task.description}\n`;
+    }
+    if (task.context) {
+      prompt += `\n**Context**:\n${task.context}\n`;
+    }
+    if (task.requirements) {
+      prompt += `\n**Requirements**:\n${task.requirements}\n`;
+    }
+    prompt += `\nPlease complete the task diligently. Produce real, working output. Be efficient and give a final summary after completing the work.`;
+    return prompt;
+  }
+
+  /**
+   * Serialize (for persistence)
+   */
+  serialize() {
+    const customBackends = [];
+    for (const [id, backend] of this.backends) {
+      if (!backend.config.builtin) {
+        customBackends.push(backend.config);
+      }
+    }
+    return {
+      customBackends,
+      savedAt: new Date().toISOString(),
+    };
+  }
+
+  /**
+   * Restore custom backends from serialized data
+   */
+  restore(data) {
+    if (!data || !data.customBackends) return;
+    for (const config of data.customBackends) {
+      try {
+        this.register(config);
+      } catch (e) {
+        console.error(`[CLIBackendRegistry] Failed to restore backend "${config.id}":`, e.message);
+      }
+    }
+  }
+}
+
+// Global singleton
+export const cliBackendRegistry = new CLIBackendRegistry();