@sylphx/flow 1.0.1 → 1.0.3

package/src/services/functional/evaluation-logic.ts

@@ -0,0 +1,296 @@
+/**
+ * Business logic for evaluation service
+ * Pure functions for evaluation processing
+ *
+ * DESIGN RATIONALE:
+ * - Pure functions for data transformation
+ * - Testable without file system or child processes
+ * - Clear separation of I/O and logic
+ * - Composable evaluation pipeline
+ */
+
+import type { FileSystemError } from '../../core/functional/error-types.js';
+import { fileSystemError } from '../../core/functional/error-types.js';
+import { pipe } from '../../core/functional/pipe.js';
+import type { Result } from '../../core/functional/result.js';
+import { failure, success } from '../../core/functional/result.js';
+import { Arr, Obj, Str } from '../../utils/functional/index.js';
+
+/**
+ * Domain types
+ */
+
+export interface AgentTiming {
+  duration: number;
+}
+
+export interface AgentTimings {
+  [agentName: string]: AgentTiming;
+}
+
+export interface PerformanceScoreRange {
+  max: number;
+  score: number;
+  label: string;
+}
+
+export interface AgentPerformanceData {
+  agent: string;
+  duration: number;
+  score: number;
+  label: string;
+}
+
+export interface EvaluationTemplate {
+  content: string;
+  variables: string[];
+}
+
+/**
+ * Pure functions for timing processing
+ */
+
+/**
+ * Parse duration from execution time text
+ */
+export const parseDuration = (content: string): number => {
+  const match = content.match(/Duration:\s*(\d+)\s*seconds/);
+  return match ? Number.parseInt(match[1], 10) : 0;
+};
+
+/**
+ * Parse timing from JSON
+ */
+export const parseTimingJSON = (content: string): Result<AgentTiming, FileSystemError> => {
+  try {
+    const data = JSON.parse(content);
+    return success({ duration: data.duration || 0 });
+  } catch (error) {
+    return failure(
+      fileSystemError('Failed to parse timing JSON', '', 'read', {
+        cause: error instanceof Error ? error : undefined,
+      })
+    );
+  }
+};
+
+/**
+ * Find performance score range for duration
+ */
+export const findScoreRange = (
+  duration: number,
+  ranges: PerformanceScoreRange[]
+): PerformanceScoreRange => {
+  const found = ranges.find((range) => duration <= range.max);
+  return found || ranges[ranges.length - 1];
+};
+
+/**
+ * Calculate agent performance data
+ */
+export const calculatePerformance = (
+  agentName: string,
+  timing: AgentTiming,
+  scoreRanges: PerformanceScoreRange[]
+): AgentPerformanceData => {
+  const scoreRange = findScoreRange(timing.duration, scoreRanges);
+  return {
+    agent: agentName,
+    duration: timing.duration,
+    score: scoreRange.score,
+    label: scoreRange.label,
+  };
+};
+
+/**
+ * Format agent performance as string
+ */
+export const formatPerformance = (data: AgentPerformanceData): string => {
+  return `- ${data.agent}: ${data.duration}s execution time (Performance: ${data.score}/10)`;
+};
+
+/**
+ * Generate performance data section
+ */
+export const generatePerformanceSection = (
+  timings: AgentTimings,
+  scoreRanges: PerformanceScoreRange[]
+): string => {
+  return pipe(
+    Obj.entries(timings),
+    Arr.map(([agent, timing]) => calculatePerformance(agent, timing, scoreRanges)),
+    Arr.map(formatPerformance),
+    Str.join('\n')
+  );
+};
+
+/**
+ * Template variable replacement (pure)
+ */
+export const replaceTemplateVariables = (
+  template: string,
+  variables: Record<string, string>
+): string => {
+  let result = template;
+
+  for (const [key, value] of Obj.entries(variables)) {
+    const placeholder = `{{${String(key)}}}`;
+    result = Str.replaceAll(placeholder, value)(result);
+  }
+
+  return result;
+};
+
+/**
+ * Parse template and find variables
+ */
+export const parseTemplate = (content: string): EvaluationTemplate => {
+  const variablePattern = /\{\{([A-Z_]+)\}\}/g;
+  const variables: string[] = [];
+
+  let match;
+  while ((match = variablePattern.exec(content)) !== null) {
+    if (!variables.includes(match[1])) {
+      variables.push(match[1]);
+    }
+  }
+
+  return {
+    content,
+    variables,
+  };
+};
+
+/**
+ * Build evaluation prompt from template
+ */
+export const buildEvaluationPrompt = (
+  template: string,
+  timings: AgentTimings,
+  scoreRanges: PerformanceScoreRange[]
+): string => {
+  const performanceData = generatePerformanceSection(timings, scoreRanges);
+
+  return replaceTemplateVariables(template, {
+    AGENT_PERFORMANCE_DATA: performanceData,
+  });
+};
+
+/**
+ * Format agent work content
+ */
+export const formatAgentWork = (agentName: string, files: string[]): string => {
+  const header = `=== ${agentName} WORK ===\n\n`;
+  const fileContents = files.map((content) => content).join('\n');
+  return header + fileContents;
+};
+
+/**
+ * Format file content
+ */
+export const formatFileContent = (fileName: string, content: string): string => {
+  return `\n--- File: ${fileName} ---\n${content}\n`;
+};
+
+/**
+ * Combine agent work sections
+ */
+export const combineAgentWork = (workSections: string[]): string => {
+  const separator = `\n${'='.repeat(80)}\n`;
+  return workSections.join(separator);
+};
+
+/**
+ * Build full evaluation input
+ */
+export const buildEvaluationInput = (prompt: string, agentWork: string): string => {
+  return `${prompt}\n\nAGENT WORK TO EVALUATE:\n${agentWork}`;
+};
+
+/**
+ * Validate evaluation template
+ */
+export const validateTemplate = (template: string): Result<string, FileSystemError> => {
+  if (Str.isBlank(template)) {
+    return failure(fileSystemError('Template is empty', '', 'read'));
+  }
+
+  const parsed = parseTemplate(template);
+  if (!parsed.variables.includes('AGENT_PERFORMANCE_DATA')) {
+    return failure(
+      fileSystemError('Template missing required variable: AGENT_PERFORMANCE_DATA', '', 'read')
+    );
+  }
+
+  return success(template);
+};
+
+/**
+ * Extract summary statistics from agent work
+ */
+export const extractSummaryStats = (agentWork: Record<string, string>): Record<string, number> => {
+  return pipe(
+    Obj.entries(agentWork),
+    Arr.map(([agent, content]) => {
+      const fileCount = (content.match(/--- File: /g) || []).length;
+      return [agent, fileCount] as [string, number];
+    }),
+    Obj.fromEntries
+  );
+};
+
+/**
+ * Format summary statistics
+ */
+export const formatSummaryStats = (stats: Record<string, number>): string => {
+  return pipe(
+    Obj.entries(stats),
+    Arr.map(([agent, count]) => `${agent}: ${count} files created`),
+    Str.join('\n')
+  );
+};
+
+/**
+ * Parse evaluation output (extract sections)
+ */
+export const parseEvaluationOutput = (
+  output: string
+): {
+  sections: Array<{ title: string; content: string }>;
+} => {
+  const sections: Array<{ title: string; content: string }> = [];
+  const lines = Str.lines(output);
+
+  let currentSection: { title: string; content: string } | null = null;
+
+  for (const line of lines) {
+    if (line.startsWith('##')) {
+      if (currentSection) {
+        sections.push(currentSection);
+      }
+      currentSection = {
+        title: line.replace(/^##\s*/, '').trim(),
+        content: '',
+      };
+    } else if (currentSection) {
+      currentSection.content += `${line}\n`;
+    }
+  }
+
+  if (currentSection) {
+    sections.push(currentSection);
+  }
+
+  return { sections };
+};
+
+/**
+ * Default performance score ranges
+ */
+export const DEFAULT_SCORE_RANGES: PerformanceScoreRange[] = [
+  { max: 30, score: 10, label: 'Excellent' },
+  { max: 60, score: 8, label: 'Good' },
+  { max: 120, score: 6, label: 'Fair' },
+  { max: 240, score: 4, label: 'Slow' },
+  { max: Number.POSITIVE_INFINITY, score: 2, label: 'Very Slow' },
+];

package/src/services/functional/file-processor.ts

@@ -0,0 +1,273 @@
+/**
+ * Functional file processing service
+ * Pure file transformations separated from I/O
+ *
+ * DESIGN RATIONALE:
+ * - Pure transformation functions
+ * - Composable processing pipeline
+ * - Side effects (I/O) explicit and isolated
+ * - Testable without file system
+ */
+
+import type { FileSystemError } from '../../core/functional/error-types.js';
+import { fileSystemError } from '../../core/functional/error-types.js';
+import type { Result } from '../../core/functional/result.js';
+import { all, failure, success } from '../../core/functional/result.js';
+
+/**
+ * Domain types
+ */
+
+export interface FileContent {
+  path: string;
+  content: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface ProcessedFile {
+  originalPath: string;
+  processedContent: string;
+  metadata: Record<string, unknown>;
+}
+
+export type FileTransform = (content: string) => string;
+export type FileValidator = (content: string) => Result<string, FileSystemError>;
+
+/**
+ * Pure transformation functions
+ */
+
+/**
+ * Trim whitespace from content
+ */
+export const trimContent: FileTransform = (content: string): string => {
+  return content.trim();
+};
+
+/**
+ * Normalize line endings to \n
+ */
+export const normalizeLineEndings: FileTransform = (content: string): string => {
+  return content.replace(/\r\n/g, '\n');
+};
+
+/**
+ * Remove trailing whitespace from each line
+ */
+export const removeTrailingWhitespace: FileTransform = (content: string): string => {
+  return content
+    .split('\n')
+    .map((line) => line.trimEnd())
+    .join('\n');
+};
+
+/**
+ * Ensure file ends with newline
+ */
+export const ensureTrailingNewline: FileTransform = (content: string): string => {
+  if (!content.endsWith('\n')) {
+    return `${content}\n`;
+  }
+  return content;
+};
+
+/**
+ * Remove consecutive blank lines (keep max 1)
+ */
+export const collapseBlankLines: FileTransform = (content: string): string => {
+  return content.replace(/\n\n\n+/g, '\n\n');
+};
+
+/**
+ * Apply multiple transforms in sequence
+ */
+export const composeTransforms = (...transforms: FileTransform[]): FileTransform => {
+  return (content: string) => transforms.reduce((acc, transform) => transform(acc), content);
+};
+
+/**
+ * Standard cleanup pipeline
+ */
+export const standardCleanup: FileTransform = composeTransforms(
+  normalizeLineEndings,
+  removeTrailingWhitespace,
+  collapseBlankLines,
+  ensureTrailingNewline
+);
+
+/**
+ * Validation functions
+ */
+
+/**
+ * Validate content is not empty
+ */
+export const validateNotEmpty: FileValidator = (
+  content: string
+): Result<string, FileSystemError> => {
+  if (content.trim().length === 0) {
+    return failure(fileSystemError('File content is empty', '', 'read'));
+  }
+  return success(content);
+};
+
+/**
+ * Validate content size
+ */
+export const validateSize =
+  (maxBytes: number): FileValidator =>
+  (content: string): Result<string, FileSystemError> => {
+    const bytes = Buffer.byteLength(content, 'utf-8');
+    if (bytes > maxBytes) {
+      return failure(
+        fileSystemError(`File content exceeds maximum size: ${bytes} > ${maxBytes}`, '', 'read', {
+          context: { bytes, maxBytes },
+        })
+      );
+    }
+    return success(content);
+  };
+
+/**
+ * Validate content matches pattern
+ */
+export const validatePattern =
+  (pattern: RegExp, message: string): FileValidator =>
+  (content: string): Result<string, FileSystemError> => {
+    if (!pattern.test(content)) {
+      return failure(fileSystemError(message, '', 'read'));
+    }
+    return success(content);
+  };
+
+/**
+ * Compose validators
+ */
+export const composeValidators =
+  (...validators: FileValidator[]): FileValidator =>
+  (content: string): Result<string, FileSystemError> => {
+    for (const validator of validators) {
+      const result = validator(content);
+      if (result._tag === 'Failure') {
+        return result;
+      }
+    }
+    return success(content);
+  };
+
+/**
+ * File processing operations
+ */
+
+/**
+ * Process a single file (pure transformation)
+ */
+export const processFileContent = (
+  file: FileContent,
+  transform: FileTransform,
+  validator?: FileValidator
+): Result<ProcessedFile, FileSystemError> => {
+  // Validate if validator provided
+  if (validator) {
+    const validationResult = validator(file.content);
+    if (validationResult._tag === 'Failure') {
+      return validationResult;
+    }
+  }
+
+  // Apply transformation
+  const processedContent = transform(file.content);
+
+  return success({
+    originalPath: file.path,
+    processedContent,
+    metadata: {
+      ...file.metadata,
+      processed: true,
+      originalLength: file.content.length,
+      processedLength: processedContent.length,
+    },
+  });
+};
+
+/**
+ * Process multiple files
+ */
+export const processFiles = (
+  files: FileContent[],
+  transform: FileTransform,
+  validator?: FileValidator
+): Result<ProcessedFile[], FileSystemError> => {
+  const results = files.map((file) => processFileContent(file, transform, validator));
+
+  return all(results);
+};
+
+/**
+ * Filter files by extension (pure)
+ */
+export const filterByExtension =
+  (extensions: string[]) =>
+  (files: FileContent[]): FileContent[] => {
+    return files.filter((file) => {
+      const ext = file.path.split('.').pop()?.toLowerCase();
+      return ext && extensions.includes(ext);
+    });
+  };
+
+/**
+ * Filter files by pattern (pure)
+ */
+export const filterByPattern =
+  (pattern: RegExp) =>
+  (files: FileContent[]): FileContent[] => {
+    return files.filter((file) => pattern.test(file.path));
+  };
+
+/**
+ * Sort files by path (pure)
+ */
+export const sortByPath = (files: FileContent[]): FileContent[] => {
+  return [...files].sort((a, b) => a.path.localeCompare(b.path));
+};
+
+/**
+ * Group files by directory (pure)
+ */
+export const groupByDirectory = (files: FileContent[]): Record<string, FileContent[]> => {
+  return files.reduce(
+    (acc, file) => {
+      const dir = file.path.split('/').slice(0, -1).join('/') || '.';
+      if (!acc[dir]) {
+        acc[dir] = [];
+      }
+      acc[dir].push(file);
+      return acc;
+    },
+    {} as Record<string, FileContent[]>
+  );
+};
+
+/**
+ * Extract metadata from content (pure)
+ */
+export const extractMetadata =
+  (extractor: (content: string) => Record<string, unknown>) =>
+  (file: FileContent): FileContent => {
+    return {
+      ...file,
+      metadata: {
+        ...file.metadata,
+        ...extractor(file.content),
+      },
+    };
+  };
+
+/**
+ * Building block for file processing pipelines
+ */
+export const createFileProcessor = (transform: FileTransform, validator?: FileValidator) => {
+  return (files: FileContent[]): Result<ProcessedFile[], FileSystemError> => {
+    return processFiles(files, transform, validator);
+  };
+};

package/src/services/functional/index.ts

@@ -0,0 +1,12 @@
+/**
+ * Functional services
+ * Business logic as composable pure functions
+ *
+ * DESIGN RATIONALE:
+ * - Services as collections of pure functions
+ * - Side effects isolated to service boundaries
+ * - Composable through functional patterns
+ * - Testable without mocking
+ */
+
+export * from './file-processor.js';

package/src/services/index.ts

@@ -0,0 +1,13 @@
+/**
+ * Service modules barrel export
+ * Centralized access to service layer functionality
+ */
+
+// Re-export commonly used service functions
+export {
+  configureServers,
+  default as mcpService,
+  installServers,
+  listAvailableServers,
+  validateServerConfiguration,
+} from './mcp-service';