@sylphx/flow 1.0.1 → 1.0.3

package/src/utils/session-title.ts

@@ -0,0 +1,87 @@
+/**
+ * Session Title Generation Utility
+ * Re-exports pure functions from feature and adds streaming functionality
+ */
+
+import { createAIStream } from '../core/ai-sdk.js';
+import type { ProviderId } from '../types/config.types.js';
+
+// Re-export pure functions from feature
+export {
+  generateSessionTitle,
+  formatSessionDisplay,
+  formatRelativeTime,
+  cleanTitle,
+  truncateTitle,
+} from '../features/session/utils/title.js';
+
+/**
+ * Generate a session title using LLM with streaming
+ */
+export async function generateSessionTitleWithStreaming(
+  firstMessage: string,
+  provider: ProviderId,
+  modelName: string,
+  providerConfig: any,
+  onChunk: (chunk: string) => void
+): Promise<string> {
+  if (!firstMessage || firstMessage.trim().length === 0) {
+    return 'New Chat';
+  }
+
+  try {
+    // Get the provider instance and create the model
+    const { getProvider } = await import('../providers/index.js');
+    const providerInstance = getProvider(provider);
+    const model = providerInstance.createClient(providerConfig, modelName);
+
+    const streamGenerator = createAIStream({
+      model,
+      messages: [
+        {
+          role: 'user',
+          content: `You need to generate a SHORT, DESCRIPTIVE title (maximum 50 characters) for a chat conversation.
+
+User's first message: "${firstMessage}"
+
+Requirements:
+- Summarize the TOPIC or INTENT, don't just copy the message
+- Be concise and descriptive
+- Maximum 50 characters
+- Output ONLY the title, nothing else
+
+Examples:
+- Message: "How do I implement authentication?" → Title: "Authentication Implementation"
+- Message: "你好，请帮我修复这个 bug" → Title: "Bug 修复请求"
+- Message: "Can you help me with React hooks?" → Title: "React Hooks Help"
+
+Now generate the title:`,
+        },
+      ],
+    });
+
+    let fullTitle = '';
+
+    // Iterate the async generator and stream to UI
+    for await (const chunk of streamGenerator) {
+      if (chunk.type === 'text-delta' && chunk.textDelta) {
+        fullTitle += chunk.textDelta;
+        onChunk(chunk.textDelta);
+      }
+    }
+
+    // Clean up title
+    let cleaned = fullTitle.trim();
+    cleaned = cleaned.replace(/^["'「『]+|["'」』]+$/g, ''); // Remove quotes
+    cleaned = cleaned.replace(/^(Title:|标题：)\s*/i, ''); // Remove "Title:" prefix
+    cleaned = cleaned.replace(/\n+/g, ' '); // Replace newlines with spaces
+    cleaned = cleaned.trim();
+
+    // Return truncated if needed
+    return cleaned.length > 50 ? cleaned.substring(0, 50) + '...' : cleaned;
+  } catch (error) {
+    // Fallback to simple title generation on any error
+    return generateSessionTitle(firstMessage);
+  }
+}
+

package/src/utils/settings.ts

@@ -0,0 +1,182 @@
+/**
+ * Project settings manager - functional implementation
+ * Pure functions for managing uncommitted project-specific settings
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { type Result, success, tryCatchAsync } from '../core/functional/result.js';
+
+export interface ProjectSettings {
+  /** Default target for the project */
+  defaultTarget?: string;
+  /** Settings version for migration purposes */
+  version?: string;
+}
+
+const SETTINGS_FILE = '.sylphx-flow/settings.json';
+const CURRENT_VERSION = '1.0.0';
+
+/**
+ * Get settings file path for a given working directory
+ */
+export const getSettingsPath = (cwd: string = process.cwd()): string =>
+  path.join(cwd, SETTINGS_FILE);
+
+/**
+ * Check if settings file exists
+ */
+export const settingsExists = async (cwd: string = process.cwd()): Promise<boolean> => {
+  try {
+    await fs.access(getSettingsPath(cwd));
+    return true;
+  } catch {
+    return false;
+  }
+};
+
+/**
+ * Load project settings from file
+ * Returns Result type for explicit error handling
+ */
+export const loadSettings = async (
+  cwd: string = process.cwd()
+): Promise<Result<ProjectSettings, Error>> => {
+  const settingsPath = getSettingsPath(cwd);
+
+  return tryCatchAsync(
+    async () => {
+      const content = await fs.readFile(settingsPath, 'utf8');
+      return JSON.parse(content) as ProjectSettings;
+    },
+    (error: any) => {
+      // File not found is not an error - return empty settings
+      if (error.code === 'ENOENT') {
+        return new Error('EMPTY_SETTINGS');
+      }
+      return new Error(`Failed to load settings: ${error.message}`);
+    }
+  ).then((result) => {
+    // Convert EMPTY_SETTINGS error to success with empty object
+    if (result._tag === 'Failure' && result.error.message === 'EMPTY_SETTINGS') {
+      return success({});
+    }
+    return result;
+  });
+};
+
+/**
+ * Save project settings to file
+ * Returns Result type for explicit error handling
+ */
+export const saveSettings = async (
+  settings: ProjectSettings,
+  cwd: string = process.cwd()
+): Promise<Result<void, Error>> => {
+  const settingsPath = getSettingsPath(cwd);
+
+  return tryCatchAsync(
+    async () => {
+      // Ensure the directory exists
+      await fs.mkdir(path.dirname(settingsPath), { recursive: true });
+
+      // Add current version if not present
+      const settingsWithVersion = {
+        ...settings,
+        version: settings.version || CURRENT_VERSION,
+      };
+
+      // Write settings with proper formatting
+      await fs.writeFile(settingsPath, `${JSON.stringify(settingsWithVersion, null, 2)}\n`, 'utf8');
+    },
+    (error: any) => new Error(`Failed to save settings: ${error.message}`)
+  );
+};
+
+/**
+ * Update specific settings properties
+ */
+export const updateSettings = async (
+  updates: Partial<ProjectSettings>,
+  cwd: string = process.cwd()
+): Promise<Result<void, Error>> => {
+  const currentResult = await loadSettings(cwd);
+
+  if (currentResult._tag === 'Failure') {
+    return currentResult;
+  }
+
+  const newSettings = { ...currentResult.value, ...updates };
+  return saveSettings(newSettings, cwd);
+};
+
+/**
+ * Get the default target from settings
+ */
+export const getDefaultTarget = async (
+  cwd: string = process.cwd()
+): Promise<string | undefined> => {
+  const result = await loadSettings(cwd);
+  return result._tag === 'Success' ? result.value.defaultTarget : undefined;
+};
+
+/**
+ * Set the default target in settings
+ */
+export const setDefaultTarget = async (
+  target: string,
+  cwd: string = process.cwd()
+): Promise<Result<void, Error>> => updateSettings({ defaultTarget: target }, cwd);
+
+/**
+ * Legacy class-based interface for backward compatibility
+ * @deprecated Use functional exports instead (loadSettings, saveSettings, etc.)
+ */
+export class ProjectSettings {
+  constructor(private cwd: string = process.cwd()) {
+    this.settingsPath = getSettingsPath(cwd);
+  }
+
+  async load(): Promise<ProjectSettings> {
+    const result = await loadSettings(this.cwd);
+    if (result._tag === 'Failure') {
+      throw result.error;
+    }
+    return result.value;
+  }
+
+  async save(settings: ProjectSettings): Promise<void> {
+    const result = await saveSettings(settings, this.cwd);
+    if (result._tag === 'Failure') {
+      throw result.error;
+    }
+  }
+
+  async update(updates: Partial<ProjectSettings>): Promise<void> {
+    const result = await updateSettings(updates, this.cwd);
+    if (result._tag === 'Failure') {
+      throw result.error;
+    }
+  }
+
+  async getDefaultTarget(): Promise<string | undefined> {
+    return getDefaultTarget(this.cwd);
+  }
+
+  async setDefaultTarget(target: string): Promise<void> {
+    const result = await setDefaultTarget(target, this.cwd);
+    if (result._tag === 'Failure') {
+      throw result.error;
+    }
+  }
+
+  async exists(): Promise<boolean> {
+    return settingsExists(this.cwd);
+  }
+}
+
+/**
+ * Singleton instance for backward compatibility
+ * @deprecated Use functional exports with explicit cwd parameter
+ */
+export const projectSettings = new ProjectSettings();

package/src/utils/simplified-errors.ts

@@ -0,0 +1,410 @@
+/**
+ * Simplified Error Handling System
+ * Reduces complexity from 11+ error types to 3 core types
+ */
+
+import { logger } from './logger.js';
+
+/**
+ * Error severity levels
+ */
+export enum ErrorSeverity {
+  LOW = 'LOW',
+  MEDIUM = 'MEDIUM',
+  HIGH = 'HIGH',
+  CRITICAL = 'CRITICAL',
+}
+
+/**
+ * Error categories for classification
+ */
+export enum ErrorCategory {
+  VALIDATION = 'VALIDATION',
+  CONFIGURATION = 'CONFIGURATION',
+  DATABASE = 'DATABASE',
+  NETWORK = 'NETWORK',
+  FILESYSTEM = 'FILESYSTEM',
+  AUTHENTICATION = 'AUTHENTICATION',
+  RUNTIME = 'RUNTIME',
+  EXTERNAL = 'EXTERNAL',
+  INTERNAL = 'INTERNAL',
+}
+
+/**
+ * Core error interface
+ */
+export interface ErrorInfo {
+  code: string;
+  message: string;
+  category: ErrorCategory;
+  severity: ErrorSeverity;
+  context?: Record<string, unknown>;
+  cause?: Error;
+  timestamp: string;
+  id: string;
+}
+
+/**
+ * Simplified Error Class - The main error type for most use cases
+ */
+export class AppError extends Error implements ErrorInfo {
+  public readonly code: string;
+  public readonly category: ErrorCategory;
+  public readonly severity: ErrorSeverity;
+  public readonly context?: Record<string, unknown>;
+  public readonly timestamp: string;
+  public readonly id: string;
+
+  constructor(
+    message: string,
+    code: string,
+    category: ErrorCategory = ErrorCategory.RUNTIME,
+    severity: ErrorSeverity = ErrorSeverity.MEDIUM,
+    context?: Record<string, unknown>,
+    cause?: Error
+  ) {
+    super(message, { cause });
+    this.name = 'AppError';
+    this.code = code;
+    this.category = category;
+    this.severity = severity;
+    this.context = context;
+    this.timestamp = new Date().toISOString();
+    this.id = this.generateErrorId();
+
+    // Log the error
+    this.logError();
+  }
+
+  private generateErrorId(): string {
+    return `err_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  private logError(): void {
+    const logLevel = this.getLogLevel();
+    logger[logLevel]('AppError occurred', {
+      id: this.id,
+      code: this.code,
+      message: this.message,
+      category: this.category,
+      severity: this.severity,
+      context: this.context,
+      stack: this.stack,
+    });
+  }
+
+  private getLogLevel(): 'error' | 'warn' | 'info' | 'debug' {
+    switch (this.severity) {
+      case ErrorSeverity.CRITICAL:
+      case ErrorSeverity.HIGH:
+        return 'error';
+      case ErrorSeverity.MEDIUM:
+        return 'warn';
+      case ErrorSeverity.LOW:
+        return 'info';
+      default:
+        return 'debug';
+    }
+  }
+
+  /**
+   * Convert to JSON for serialization
+   */
+  toJSON(): ErrorInfo {
+    return {
+      code: this.code,
+      message: this.message,
+      category: this.category,
+      severity: this.severity,
+      context: this.context,
+      cause: this.cause?.message,
+      timestamp: this.timestamp,
+      id: this.id,
+    };
+  }
+
+  /**
+   * Get user-friendly message
+   */
+  getUserMessage(): string {
+    // For validation errors, be more specific
+    if (this.category === ErrorCategory.VALIDATION) {
+      return `Validation failed: ${this.message}`;
+    }
+
+    // For configuration errors, provide actionable guidance
+    if (this.category === ErrorCategory.CONFIGURATION) {
+      return `Configuration error: ${this.message}. Please check your settings.`;
+    }
+
+    // For database errors, be more generic
+    if (this.category === ErrorCategory.DATABASE) {
+      return 'Database operation failed. Please try again later.';
+    }
+
+    // For network/external errors
+    if (this.category === ErrorCategory.NETWORK || this.category === ErrorCategory.EXTERNAL) {
+      return 'External service unavailable. Please try again later.';
+    }
+
+    // Default message
+    return this.message;
+  }
+}
+
+/**
+ * Validation Error - For input validation failures
+ */
+export class ValidationError extends AppError {
+  constructor(message: string, field?: string, value?: unknown) {
+    const context = field ? { field, value } : undefined;
+    super(message, 'VALIDATION_ERROR', ErrorCategory.VALIDATION, ErrorSeverity.LOW, context);
+    this.name = 'ValidationError';
+  }
+}
+
+/**
+ * Configuration Error - For configuration issues
+ */
+export class ConfigurationError extends AppError {
+  constructor(message: string, configKey?: string) {
+    const context = configKey ? { configKey } : undefined;
+    super(message, 'CONFIG_ERROR', ErrorCategory.CONFIGURATION, ErrorSeverity.HIGH, context);
+    this.name = 'ConfigurationError';
+  }
+}
+
+/**
+ * Database Error - For database operation failures
+ */
+export class DatabaseError extends AppError {
+  constructor(message: string, operation?: string, query?: string) {
+    const context = operation ? { operation, query } : undefined;
+    super(message, 'DATABASE_ERROR', ErrorCategory.DATABASE, ErrorSeverity.HIGH, context);
+    this.name = 'DatabaseError';
+  }
+}
+
+/**
+ * Network Error - For network-related failures
+ */
+export class NetworkError extends AppError {
+  constructor(message: string, url?: string, statusCode?: number) {
+    const context = url ? { url, statusCode } : undefined;
+    super(message, 'NETWORK_ERROR', ErrorCategory.NETWORK, ErrorSeverity.MEDIUM, context);
+    this.name = 'NetworkError';
+  }
+}
+
+/**
+ * Filesystem Error - For file system operations
+ */
+export class FilesystemError extends AppError {
+  constructor(message: string, path?: string, operation?: string) {
+    const context = path ? { path, operation } : undefined;
+    super(message, 'FILESYSTEM_ERROR', ErrorCategory.FILESYSTEM, ErrorSeverity.MEDIUM, context);
+    this.name = 'FilesystemError';
+  }
+}
+
+/**
+ * Authentication Error - For auth failures
+ */
+export class AuthenticationError extends AppError {
+  constructor(message = 'Authentication failed') {
+    super(message, 'AUTH_ERROR', ErrorCategory.AUTHENTICATION, ErrorSeverity.HIGH);
+    this.name = 'AuthenticationError';
+  }
+}
+
+/**
+ * Error factory for convenient error creation
+ */
+export class ErrorFactory {
+  /**
+   * Create validation error
+   */
+  static validation(message: string, field?: string, value?: unknown): ValidationError {
+    return new ValidationError(message, field, value);
+  }
+
+  /**
+   * Create configuration error
+   */
+  static configuration(message: string, configKey?: string): ConfigurationError {
+    return new ConfigurationError(message, configKey);
+  }
+
+  /**
+   * Create database error
+   */
+  static database(message: string, operation?: string, query?: string): DatabaseError {
+    return new DatabaseError(message, operation, query);
+  }
+
+  /**
+   * Create network error
+   */
+  static network(message: string, url?: string, statusCode?: number): NetworkError {
+    return new NetworkError(message, url, statusCode);
+  }
+
+  /**
+   * Create filesystem error
+   */
+  static filesystem(message: string, path?: string, operation?: string): FilesystemError {
+    return new FilesystemError(message, path, operation);
+  }
+
+  /**
+   * Create authentication error
+   */
+  static authentication(message?: string): AuthenticationError {
+    return new AuthenticationError(message);
+  }
+
+  /**
+   * Create generic app error
+   */
+  static app(
+    message: string,
+    code: string,
+    category: ErrorCategory = ErrorCategory.RUNTIME,
+    severity: ErrorSeverity = ErrorSeverity.MEDIUM,
+    context?: Record<string, unknown>
+  ): AppError {
+    return new AppError(message, code, category, severity, context);
+  }
+
+  /**
+   * Create error from unknown error type
+   */
+  static fromUnknown(error: unknown, defaultMessage = 'Unknown error occurred'): AppError {
+    if (error instanceof AppError) {
+      return error;
+    }
+
+    if (error instanceof Error) {
+      return new AppError(
+        error.message,
+        'UNKNOWN_ERROR',
+        ErrorCategory.INTERNAL,
+        ErrorSeverity.MEDIUM,
+        { originalError: error.name },
+        error
+      );
+    }
+
+    if (typeof error === 'string') {
+      return new AppError(error, 'STRING_ERROR', ErrorCategory.INTERNAL, ErrorSeverity.LOW);
+    }
+
+    return new AppError(
+      defaultMessage,
+      'UNKNOWN_ERROR',
+      ErrorCategory.INTERNAL,
+      ErrorSeverity.MEDIUM,
+      { originalError: error }
+    );
+  }
+}
+
+/**
+ * Error handler utility class
+ */
+export class ErrorHandler {
+  /**
+   * Handle error and convert to user-friendly response
+   */
+  static handle(error: unknown): { message: string; code: string; severity: ErrorSeverity } {
+    const appError = ErrorFactory.fromUnknown(error);
+
+    return {
+      message: appError.getUserMessage(),
+      code: appError.code,
+      severity: appError.severity,
+    };
+  }
+
+  /**
+   * Execute operation with error handling
+   */
+  static async execute<T>(
+    operation: () => Promise<T>,
+    errorContext?: Record<string, unknown>
+  ): Promise<{ success: true; data: T } | { success: false; error: AppError }> {
+    try {
+      const data = await operation();
+      return { success: true, data };
+    } catch (error) {
+      const appError = ErrorFactory.fromUnknown(error);
+
+      // Add context if provided
+      if (errorContext) {
+        appError.context = { ...appError.context, ...errorContext };
+      }
+
+      return { success: false, error: appError };
+    }
+  }
+
+  /**
+   * Check if error is recoverable
+   */
+  static isRecoverable(error: Error): boolean {
+    if (error instanceof AppError) {
+      return error.severity !== ErrorSeverity.CRITICAL;
+    }
+    return true; // Assume unknown errors are recoverable
+  }
+
+  /**
+   * Get retry delay for error
+   */
+  static getRetryDelay(error: Error, attempt: number): number {
+    if (error instanceof AppError) {
+      switch (error.category) {
+        case ErrorCategory.NETWORK:
+        case ErrorCategory.EXTERNAL:
+          return Math.min(1000 * 2 ** attempt, 30000); // Exponential backoff
+        case ErrorCategory.DATABASE:
+          return Math.min(500 * 2 ** attempt, 5000);
+        default:
+          return 1000;
+      }
+    }
+    return 1000;
+  }
+}
+
+/**
+ * Convenience functions
+ */
+export const createValidationError = (message: string, field?: string, value?: unknown) =>
+  ErrorFactory.validation(message, field, value);
+
+export const createConfigurationError = (message: string, configKey?: string) =>
+  ErrorFactory.configuration(message, configKey);
+
+export const createDatabaseError = (message: string, operation?: string, query?: string) =>
+  ErrorFactory.database(message, operation, query);
+
+export const createNetworkError = (message: string, url?: string, statusCode?: number) =>
+  ErrorFactory.network(message, url, statusCode);
+
+export const createFilesystemError = (message: string, path?: string, operation?: string) =>
+  ErrorFactory.filesystem(message, path, operation);
+
+export const createAuthenticationError = (message?: string) => ErrorFactory.authentication(message);
+
+export const createError = (
+  message: string,
+  code: string,
+  category: ErrorCategory = ErrorCategory.RUNTIME,
+  severity: ErrorSeverity = ErrorSeverity.MEDIUM,
+  context?: Record<string, unknown>
+) => ErrorFactory.app(message, code, category, severity, context);
+
+// Legacy exports for backward compatibility
+export { AppError as BaseError };
+export type { ErrorInfo };