@sylphx/flow 1.8.0 → 1.8.2

package/src/domains/index.ts

@@ -1,6 +0,0 @@
-/**
- * Domains Index
- * Unified exports for all domain modules
- */
-
-export * from './utilities/index.js';

package/src/domains/utilities/index.ts

@@ -1,6 +0,0 @@
-/**
- * Utilities Domain
- * Common utility tools and helpers
- */
-
-export * from './time/index.js';

package/src/domains/utilities/time/index.ts

@@ -1,5 +0,0 @@
-/**
- * Time utilities domain - Time and date operations
- */
-
-export { registerTimeTools } from './tools.js';

package/src/domains/utilities/time/tools.ts

@@ -1,291 +0,0 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
-import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import { z } from 'zod';
-
-// Logger utility
-const Logger = {
-  info: (message: string) => console.error(`[INFO] ${message}`),
-  success: (message: string) => console.error(`[SUCCESS] ${message}`),
-  error: (message: string, error?: unknown) => {
-    console.error(`[ERROR] ${message}`);
-    if (error) {
-      console.error(error);
-    }
-  },
-};
-
-// Helper function to validate IANA timezone
-function isValidTimezone(timezone: string): boolean {
-  try {
-    Intl.DateTimeFormat(undefined, { timeZone: timezone });
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-// Helper function to validate time format (HH:MM)
-function isValidTimeFormat(time: string): boolean {
-  const timeRegex = /^([01]?[0-9]|2[0-3]):[0-5][0-9]$/;
-  return timeRegex.test(time);
-}
-
-// Get current time in a specific timezone
-function getCurrentTime(args: { timezone: string }): CallToolResult {
-  try {
-    const { timezone } = args;
-
-    // Validate timezone
-    if (!isValidTimezone(timezone)) {
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `✗ Invalid timezone: ${timezone}. Please use a valid IANA timezone name (e.g., 'America/New_York', 'Europe/London', 'Asia/Tokyo').`,
-          },
-        ],
-        isError: true,
-      };
-    }
-
-    // Get current time in specified timezone
-    const now = new Date();
-    const timeFormatter = new Intl.DateTimeFormat('en-US', {
-      timeZone: timezone,
-      year: 'numeric',
-      month: 'long',
-      day: 'numeric',
-      hour: '2-digit',
-      minute: '2-digit',
-      second: '2-digit',
-      timeZoneName: 'long',
-      hour12: false,
-    });
-
-    const parts = timeFormatter.formatToParts(now);
-    const formatObject: Record<string, string> = {};
-    for (const part of parts) {
-      formatObject[part.type] = part.value;
-    }
-
-    const time24 = new Intl.DateTimeFormat('en-US', {
-      timeZone: timezone,
-      hour: '2-digit',
-      minute: '2-digit',
-      hour12: false,
-    }).format(now);
-
-    const isoString = now.toLocaleString('sv-SE', { timeZone: timezone });
-
-    Logger.info(`Retrieved current time for timezone: ${timezone}`);
-    return {
-      content: [
-        {
-          type: 'text',
-          text: JSON.stringify(
-            {
-              timezone,
-              current_time: {
-                date: `${formatObject.month} ${formatObject.day}, ${formatObject.year}`,
-                time_24h: time24,
-                time_with_seconds: timeFormatter.format(now),
-                timezone_name: formatObject.timeZoneName,
-                iso_format: `${isoString.replace(' ', 'T')}Z`,
-                unix_timestamp: Math.floor(now.getTime() / 1000),
-              },
-            },
-            null,
-            2
-          ),
-        },
-      ],
-    };
-  } catch (error: unknown) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    Logger.error('Error getting current time', error);
-    return {
-      content: [
-        {
-          type: 'text',
-          text: `✗ Error getting current time: ${errorMessage}`,
-        },
-      ],
-      isError: true,
-    };
-  }
-}
-
-// Convert time between timezones
-function convertTime(args: {
-  source_timezone: string;
-  time: string;
-  target_timezone: string;
-}): CallToolResult {
-  try {
-    const { source_timezone, time, target_timezone } = args;
-
-    // Validate timezones
-    if (!isValidTimezone(source_timezone)) {
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `✗ Invalid source timezone: ${source_timezone}. Please use a valid IANA timezone name.`,
-          },
-        ],
-        isError: true,
-      };
-    }
-
-    if (!isValidTimezone(target_timezone)) {
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `✗ Invalid target timezone: ${target_timezone}. Please use a valid IANA timezone name.`,
-          },
-        ],
-        isError: true,
-      };
-    }
-
-    // Validate time format
-    if (!isValidTimeFormat(time)) {
-      return {
-        content: [
-          {
-            type: 'text',
-            text: `✗ Invalid time format: ${time}. Please use 24-hour format (HH:MM).`,
-          },
-        ],
-        isError: true,
-      };
-    }
-
-    // Parse the time and create a date object for today in source timezone
-    const [hours, minutes] = time.split(':').map(Number);
-    const now = new Date();
-
-    // Create a date object representing the time in source timezone
-    const sourceDate = new Date(now.getFullYear(), now.getMonth(), now.getDate(), hours, minutes);
-
-    // Format the source time to get the correct representation
-    const sourceFormatter = new Intl.DateTimeFormat('en-US', {
-      timeZone: source_timezone,
-      year: 'numeric',
-      month: '2-digit',
-      day: '2-digit',
-      hour: '2-digit',
-      minute: '2-digit',
-      second: '2-digit',
-      hour12: false,
-    });
-
-    const sourceParts = sourceFormatter.formatToParts(sourceDate);
-    const sourceFormatObject: Record<string, string> = {};
-    for (const part of sourceParts) {
-      sourceFormatObject[part.type] = part.value;
-    }
-
-    // Convert to target timezone
-    const targetFormatter = new Intl.DateTimeFormat('en-US', {
-      timeZone: target_timezone,
-      year: 'numeric',
-      month: 'long',
-      day: 'numeric',
-      hour: '2-digit',
-      minute: '2-digit',
-      second: '2-digit',
-      timeZoneName: 'long',
-      hour12: false,
-    });
-
-    const targetTime24 = new Intl.DateTimeFormat('en-US', {
-      timeZone: target_timezone,
-      hour: '2-digit',
-      minute: '2-digit',
-      hour12: false,
-    }).format(sourceDate);
-
-    const targetParts = targetFormatter.formatToParts(sourceDate);
-    const targetFormatObject: Record<string, string> = {};
-    for (const part of targetParts) {
-      targetFormatObject[part.type] = part.value;
-    }
-
-    const targetDate = new Date(sourceDate.toLocaleString('en-US', { timeZone: target_timezone }));
-    const timeDiffMs = targetDate.getTime() - sourceDate.getTime();
-    const timeDiffHours = Math.round(timeDiffMs / (1000 * 60 * 60));
-
-    Logger.info(`Converted time from ${source_timezone} to ${target_timezone}`);
-    return {
-      content: [
-        {
-          type: 'text',
-          text: JSON.stringify(
-            {
-              conversion: {
-                source: {
-                  timezone: source_timezone,
-                  time: time,
-                  formatted: sourceFormatter.format(sourceDate),
-                },
-                target: {
-                  timezone: target_timezone,
-                  time_24h: targetTime24,
-                  formatted: targetFormatter.format(sourceDate),
-                  date: `${targetFormatObject.month} ${targetFormatObject.day}, ${targetFormatObject.year}`,
-                  timezone_name: targetFormatObject.timeZoneName,
-                },
-                time_difference_hours: timeDiffHours,
-              },
-            },
-            null,
-            2
-          ),
-        },
-      ],
-    };
-  } catch (error: unknown) {
-    const errorMessage = error instanceof Error ? error.message : String(error);
-    Logger.error('Error converting time', error);
-    return {
-      content: [
-        {
-          type: 'text',
-          text: `✗ Error converting time: ${errorMessage}`,
-        },
-      ],
-      isError: true,
-    };
-  }
-}
-
-// Register all time tools
-export function registerTimeTools(server: McpServer) {
-  server.registerTool(
-    'get_current_time',
-    {
-      description: 'Get current time in a specific timezone or system timezone',
-      inputSchema: {
-        timezone: z
-          .string()
-          .describe("IANA timezone name (e.g., 'America/New_York', 'Europe/London')"),
-      },
-    },
-    getCurrentTime
-  );
-
-  server.registerTool(
-    'convert_time',
-    {
-      description: 'Convert time between timezones',
-      inputSchema: {
-        source_timezone: z.string().describe('Source IANA timezone name'),
-        time: z.string().describe('Time in 24-hour format (HH:MM)'),
-        target_timezone: z.string().describe('Target IANA timezone name'),
-      },
-    },
-    convertTime
-  );
-}

package/src/services/agent-service.ts

@@ -1,273 +0,0 @@
-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);
-    });
-  });
-}