@sylphx/flow 1.0.1 → 1.0.3

package/src/services/agent-service.ts

@@ -0,0 +1,273 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import type { InkMonitor } from '../components/benchmark-monitor.js';
+import { DEFAULT_AGENTS } from '../constants/benchmark-constants.js';
+import type { TimingData } from '../types/benchmark.js';
+import { getAgentsDir } from '../utils/paths.js';
+import { ProcessManager } from '../utils/process-manager.js';
+
+/**
+ * Get list of agents to run based on user selection
+ * Pure function - no state, no side effects (except validation errors)
+ */
+export async function getAgentList(agentsOption: string): Promise<string[]> {
+  if (agentsOption === 'all') {
+    return DEFAULT_AGENTS;
+  }
+
+  const selectedAgents = agentsOption.split(',').map((a) => a.trim());
+
+  // Validate selected agents
+  for (const agent of selectedAgents) {
+    if (!DEFAULT_AGENTS.includes(agent)) {
+      throw new Error(`Invalid agent: ${agent}. Available agents: ${DEFAULT_AGENTS.join(', ')}`);
+    }
+  }
+
+  return selectedAgents;
+}
+
+/**
+ * Run a single agent with the given task
+ */
+export async function runAgent(
+  agentName: string,
+  outputDir: string,
+  taskFile: string,
+  contextFile: string | undefined,
+  monitor?: InkMonitor,
+  _maxRetries = 3,
+  timeout = 3600
+): Promise<void> {
+  const agentWorkDir = path.join(outputDir, agentName);
+  await fs.mkdir(agentWorkDir, { recursive: true });
+
+  // Load agent prompt
+  const agentsDir = getAgentsDir();
+  const agentFile = path.join(agentsDir, `${agentName}.md`);
+
+  try {
+    const agentPrompt = await fs.readFile(agentFile, 'utf-8');
+
+    // Prepare task content - instruct agent to work in the temp directory
+    const taskContent = await fs.readFile(taskFile, 'utf-8');
+    let fullTask = taskContent;
+
+    if (contextFile) {
+      try {
+        const contextContent = await fs.readFile(contextFile, 'utf-8');
+        fullTask = `CONTEXT:\n${contextContent}\n\nTASK:\n${taskContent}`;
+      } catch (_error) {
+        // Silently handle context file errors
+      }
+    }
+
+    // Add instruction to work in the temp directory
+    // FUNCTIONAL: Use template string instead of +=
+    const finalTask = `${fullTask}\n\nIMPORTANT: Please implement your solution in the current working directory: ${agentWorkDir}\nThis is a temporary directory for testing, so you can create files freely without affecting any production codebase.`;
+
+    // Run Claude Code with the agent prompt
+    await runSingleAgent(agentName, agentPrompt, finalTask, agentWorkDir, monitor, timeout);
+  } catch (error) {
+    throw new Error(`Failed to load agent ${agentName}: ${error}`);
+  }
+}
+
+/**
+ * Internal helper: Run a single agent process
+ * Handles process spawning, monitoring, and cleanup
+ */
+async function runSingleAgent(
+  agentName: string,
+  agentPrompt: string,
+  fullTask: string,
+  agentWorkDir: string,
+  monitor?: InkMonitor,
+  timeout = 3600
+): Promise<void> {
+  // Write agent prompt to a temp file to avoid command line length limits
+  const tempPromptFile = path.join(agentWorkDir, '.agent-prompt.md');
+  await fs.writeFile(tempPromptFile, agentPrompt);
+
+  return new Promise((resolve, reject) => {
+    let timeoutId: NodeJS.Timeout | undefined;
+    // Set up timeout
+    timeoutId = setTimeout(() => {
+      if (claudeProcess && !claudeProcess.killed) {
+        claudeProcess.kill('SIGTERM');
+        // Force kill if it doesn't stop after 5 seconds
+        setTimeout(() => {
+          if (!claudeProcess.killed) {
+            claudeProcess.kill('SIGKILL');
+          }
+        }, 5000);
+      }
+      // Update agent status to error due to timeout
+      monitor?.updateAgentStatus(agentName, 'error');
+      reject(new Error(`Agent ${agentName} timed out after ${timeout} seconds`));
+    }, timeout * 1000);
+
+    const claudeProcess = spawn(
+      'claude',
+      [
+        '--system-prompt',
+        `@${tempPromptFile}`,
+        '--dangerously-skip-permissions',
+        '--output-format',
+        'stream-json',
+        '--verbose',
+        fullTask,
+      ],
+      {
+        cwd: agentWorkDir,
+        stdio: ['inherit', 'pipe', 'pipe'],
+        env: {
+          ...process.env,
+          // Disable buffering and progress indicators for real-time output
+          FORCE_NO_PROGRESS: '1',
+          CI: '1',
+          PYTHONUNBUFFERED: '1',
+        },
+      }
+    );
+
+    // Set the process PID for debugging
+    if (claudeProcess.pid) {
+      monitor?.setAgentPid(agentName, claudeProcess.pid);
+    }
+
+    // Track this child process for cleanup
+    ProcessManager.getInstance().trackChildProcess(claudeProcess);
+
+    // FUNCTIONAL: Use arrays for immutable buffer accumulation
+    const stdoutChunks: string[] = [];
+    const stderrChunks: string[] = [];
+    let incompleteStdoutLine = '';
+
+    claudeProcess.stdout?.on('data', (data) => {
+      const output = data.toString();
+      stdoutChunks.push(output);
+
+      // Process complete lines only - keep incomplete data in buffer
+      const combined = incompleteStdoutLine + output;
+      const lines = combined.split('\n');
+      incompleteStdoutLine = lines.pop() || ''; // Keep last incomplete line
+
+      for (const line of lines) {
+        if (!line.trim()) {
+          continue;
+        }
+
+        try {
+          const jsonData = JSON.parse(line);
+
+          if (jsonData.type === 'assistant' && jsonData.message?.content) {
+            // Extract text content and tool uses from assistant message
+            for (const content of jsonData.message.content) {
+              if (content.type === 'text') {
+                const textContent = content.text.trim();
+                if (textContent) {
+                  monitor?.addAgentOutput(agentName, textContent);
+                }
+              } else if (content.type === 'tool_use') {
+                const toolName = content.name;
+                const params = content.input || {};
+
+                // Simple tool display for benchmark output
+                const paramsStr = JSON.stringify(params);
+                const toolDisplay = paramsStr.length > 80
+                  ? `${toolName}(${paramsStr.substring(0, 77)}...)`
+                  : `${toolName}(${paramsStr})`;
+
+                monitor?.addAgentOutput(agentName, toolDisplay);
+              }
+            }
+          }
+        } catch (_e) {
+          // Skip invalid JSON (shouldn't happen with stream-json)
+        }
+      }
+
+      // Don't output directly to console when using React+Ink monitor
+      // The monitor will handle displaying relevant output
+    });
+
+    claudeProcess.stderr?.on('data', (data) => {
+      const output = data.toString();
+      stderrChunks.push(output);
+
+      // Add error output to monitor (with ANSI cleaning)
+      monitor?.addAgentOutput(agentName, `ERROR: ${output}`);
+
+      // Don't output directly to console when using React+Ink monitor
+      // The monitor will handle displaying relevant output
+    });
+
+    claudeProcess.on('close', async (code) => {
+      const endTime = Date.now();
+
+      // Update agent end time
+      const agent = monitor?.getAgents().get(agentName);
+      if (agent) {
+        agent.endTime = endTime;
+      }
+
+      // Clear timeout if process completed normally
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+
+      // All data should already be processed in stdout event handler
+
+      // Clean up temp prompt file
+      try {
+        await fs.unlink(tempPromptFile);
+      } catch (_error) {
+        // Ignore cleanup errors
+      }
+
+      // Write execution log with timing information
+      // FUNCTIONAL: Join arrays at the end instead of accumulating with +=
+      const stdoutFinal = stdoutChunks.join('');
+      const stderrFinal = stderrChunks.join('');
+      const executionLog = `Execution completed at: ${new Date(endTime).toISOString()}\nExit code: ${code}\n\n=== STDOUT ===\n${stdoutFinal}\n\n=== STDERR ===\n${stderrFinal}\n`;
+      await fs.writeFile(path.join(agentWorkDir, 'execution-log.txt'), executionLog);
+
+      // Write timing metadata
+      const timingData: TimingData = {
+        endTime,
+        exitCode: code,
+        stdoutLength: stdoutFinal.length,
+        stderrLength: stderrFinal.length,
+      };
+      await fs.writeFile(
+        path.join(agentWorkDir, 'timing.json'),
+        JSON.stringify(timingData, null, 2)
+      );
+
+      // Update agent status based on exit code
+      if (code === 0) {
+        monitor?.updateAgentStatus(agentName, 'completed');
+        resolve();
+      } else {
+        monitor?.updateAgentStatus(agentName, 'error');
+        await fs.writeFile(path.join(agentWorkDir, 'execution-error.txt'), stderrFinal);
+
+        reject(new Error(`Agent ${agentName} failed with code ${code}`));
+      }
+    });
+
+    claudeProcess.on('error', (error) => {
+      // Clear timeout on error
+      if (timeoutId) {
+        clearTimeout(timeoutId);
+      }
+
+      // Update agent status to error
+      monitor?.updateAgentStatus(agentName, 'error');
+
+      reject(error);
+    });
+  });
+}

package/src/services/claude-config-service.ts

@@ -0,0 +1,252 @@
+/**
+ * Claude Configuration Service
+ * Handles Claude Code provider configuration with layered settings
+ */
+
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import { ConfigService } from './config-service.js';
+import { loadAllAgents } from '../core/agent-loader.js';
+
+export interface ClaudeConfig {
+  claudeProvider?: string;
+  claudeProviderConfig?: {
+    ANTHROPIC_BASE_URL: string;
+    description: string;
+  };
+  claudeApiKey?: string;
+  defaultAgent?: string;
+  target?: string;
+}
+
+export class ClaudeConfigService {
+  /**
+   * Load layered Claude configuration from all sources
+   */
+  static async loadConfig(): Promise<ClaudeConfig> {
+    // API keys are in home directory
+    const userSettings = await ConfigService.loadHomeSettings();
+
+    // Other settings are in project directory
+    const projectSettings = await ConfigService.loadProjectSettings();
+
+    // Merge with project settings taking precedence over home (except API key)
+    const merged = {
+      claudeProvider: userSettings.claudeProvider || projectSettings.claudeProvider,
+      claudeProviderConfig: userSettings.claudeProviderConfig || projectSettings.claudeProviderConfig,
+      claudeApiKey: userSettings.claudeApiKey,
+      defaultAgent: projectSettings.defaultAgent,
+      target: projectSettings.target,
+    };
+
+    // Local settings have highest priority for everything except API key
+    const localSettings = await ConfigService.loadLocalSettings();
+
+    return {
+      ...merged,
+      ...localSettings,
+      // Keep API key from user settings
+      claudeApiKey: merged.claudeApiKey,
+    };
+  }
+
+  /**
+   * Save user-specific config (API keys to home, project settings to project)
+   */
+  static async saveConfig(config: ClaudeConfig): Promise<void> {
+    // Separate user-specific settings (API keys)
+    const userSettings = {
+      claudeApiKey: config.claudeApiKey,
+      claudeProvider: config.claudeProvider,
+      claudeProviderConfig: config.claudeProviderConfig,
+    };
+
+    // Other settings go to project (shareable)
+    const projectSettings = {
+      claudeProvider: config.claudeProvider,
+      defaultAgent: config.defaultAgent,
+      target: config.target,
+    };
+
+    // Save API keys to home directory (never commit)
+    if (userSettings.claudeApiKey) {
+      await ConfigService.saveHomeSettings(userSettings);
+    }
+
+    // Save project settings
+    await ConfigService.saveProjectSettings(projectSettings);
+  }
+
+  /**
+   * Configure Claude provider interactively - saves API keys to home dir
+   */
+  static async configureProvider(verbose: boolean = false): Promise<ClaudeConfig> {
+    const config = await this.loadConfig();
+
+    // Check if we already have API key configured
+    if (!config.claudeApiKey || !config.claudeProvider || verbose) {
+      console.log(chalk.cyan('📋 Claude Code Configuration\n'));
+
+      const providerAnswer = await inquirer.prompt([
+        {
+          type: 'list',
+          name: 'provider',
+          message: 'Select Claude API Provider:',
+          choices: [
+            { name: 'Anthropic (Official)', value: 'anthropic' },
+            { name: 'Z.ai (Recommended)', value: 'z.ai' },
+            { name: 'Kimi', value: 'kimi' },
+          ],
+          default: config.claudeProvider || 'z.ai',
+        },
+      ]);
+
+      // Ask for API Key
+      const keyAnswer = await inquirer.prompt([
+        {
+          type: 'password',
+          name: 'apiKey',
+          message: `Enter API Key for ${providerAnswer.provider}:`,
+          mask: '*',
+          validate: (input) => input.length > 10 || 'API Key appears too short',
+        },
+      ]);
+
+      // Provider configurations
+      const providerEnvs = {
+        'anthropic': {
+          ANTHROPIC_BASE_URL: 'https://api.anthropic.com',
+          description: 'Anthropic Official API',
+        },
+        'z.ai': {
+          ANTHROPIC_BASE_URL: 'https://api.z.ai/api/anthropic',
+          description: 'Z.ai Proxy',
+        },
+        'kimi': {
+          ANTHROPIC_BASE_URL: 'https://api.kimi.com/coding/',
+          description: 'Kimi Proxy',
+        },
+      };
+
+      const providerConfig = providerEnvs[providerAnswer.provider as keyof typeof providerEnvs];
+
+      // Save API keys to home directory (never commit)
+      await ConfigService.saveHomeSettings({
+        claudeProvider: providerAnswer.provider,
+        claudeProviderConfig: providerConfig,
+        claudeApiKey: keyAnswer.apiKey,
+      });
+
+      console.log(chalk.green(`✓ API Key saved to ~/.sylphx-flow/settings.json (secure)\n`));
+      console.log(chalk.dim(`  Provider: ${providerConfig.description}`));
+      console.log(chalk.dim(`  API Key: ${keyAnswer.apiKey.slice(0, 5)}...${keyAnswer.apiKey.slice(-4)}\n`));
+
+      // Update config for return
+      config.claudeProvider = providerAnswer.provider;
+      config.claudeProviderConfig = providerConfig;
+      config.claudeApiKey = keyAnswer.apiKey;
+
+      return config;
+    }
+
+    if (verbose) {
+      console.log(chalk.green('✓ Claude provider already configured\n'));
+      console.log(chalk.dim(`  Provider: ${config.claudeProviderConfig?.description}\n`));
+    }
+
+    return config;
+  }
+
+  /**
+   * Configure agent interactively - saves to project config (shareable)
+   * Dynamically loads available agents instead of hardcoded list
+   */
+  static async configureAgent(verbose: boolean = false): Promise<string> {
+    const config = await this.loadConfig();
+
+    if (!config.defaultAgent || verbose) {
+      try {
+        // Dynamically load all available agents
+        const agents = await loadAllAgents(process.cwd());
+
+        if (agents.length === 0) {
+          console.log(chalk.yellow('⚠ No agents found. Defaulting to "coder".\n'));
+          const defaultAgent = 'coder';
+          await ConfigService.saveProjectSettings({
+            defaultAgent,
+          });
+          return defaultAgent;
+        }
+
+        // Create choices from dynamically loaded agents
+        const choices = agents.map(agent => ({
+          name: agent.metadata.name || agent.id,
+          value: agent.id,
+        }));
+
+        const agentAnswer = await inquirer.prompt([
+          {
+            type: 'list',
+            name: 'agent',
+            message: 'Select default Agent:',
+            choices,
+            default: config.defaultAgent || (agents.find(a => a.id === 'coder')?.id || agents[0].id),
+          },
+        ]);
+
+        // Save to project-level config (shareable)
+        await ConfigService.saveProjectSettings({
+          defaultAgent: agentAnswer.agent,
+        });
+
+        const selectedAgent = agents.find(a => a.id === agentAnswer.agent);
+        const displayName = selectedAgent?.metadata.name || agentAnswer.agent;
+        console.log(chalk.green(`✓ Agent set to: ${displayName}\n`));
+
+        return agentAnswer.agent;
+      } catch (error) {
+        console.log(chalk.yellow('⚠ Failed to load agents. Defaulting to "coder".\n'));
+        console.error(error);
+
+        const defaultAgent = 'coder';
+        await ConfigService.saveProjectSettings({
+          defaultAgent,
+        });
+        return defaultAgent;
+      }
+    }
+
+    return config.defaultAgent;
+  }
+
+  /**
+   * Setup environment variables for Claude Code
+   */
+  static async setupEnvironment(verbose: boolean = false): Promise<void> {
+    const config = await this.loadConfig();
+
+    if (!config.claudeProviderConfig) {
+      throw new Error('Provider not configured. Run configureProvider() first.');
+    }
+
+    // Set environment variables
+    process.env.ANTHROPIC_BASE_URL = config.claudeProviderConfig.ANTHROPIC_BASE_URL;
+
+    if (config.claudeApiKey) {
+      process.env.ANTHROPIC_API_KEY = config.claudeApiKey;
+
+      if (verbose) {
+        console.log(chalk.dim(`  Provider: ${config.claudeProviderConfig.description}`));
+        console.log(chalk.dim(`  API Key: ${config.claudeApiKey.slice(0, 5)}...${config.claudeApiKey.slice(-4)}\n`));
+      }
+    }
+  }
+
+  /**
+   * Get the default agent
+   */
+  static async getDefaultAgent(): Promise<string> {
+    const config = await this.loadConfig();
+    return config.defaultAgent || 'coder';
+  }
+}