@sylphx/flow 1.8.0 → 1.8.2

package/src/core/service-config.ts

@@ -1,252 +0,0 @@
-/**
- * Service configuration and registration for DI container
- */
-
-import { targetManager } from '../core/target-manager.js';
-import { MemoryDatabaseClient } from '../db/memory-db.js';
-import { createMCPService } from '../services/mcp-service.js';
-import { getDefaultEmbeddingProvider } from '../services/search/embeddings.js';
-import { getSearchService } from '../services/search/unified-search-service.js';
-import { createLogger as createRealLogger } from '../utils/logger.js';
-// Import concrete implementations (will be updated as we refactor)
-import { SeparatedMemoryStorage } from '../utils/separated-storage.js';
-import { container, SERVICE_TOKENS } from './di-container.js';
-import type {
-  IConfiguration,
-  IDatabaseConnection,
-  IEmbeddingProvider,
-  ILogger,
-  IMCPService,
-  ISearchService,
-  IStorage,
-  ITargetManager,
-} from './interfaces.js';
-
-/**
- * Configure and register all core services with the DI container
- */
-export async function configureServices(): Promise<void> {
-  // Logger Service - Singleton
-  container.register<ILogger>(SERVICE_TOKENS.LOGGER, () => createLogger(), 'singleton');
-
-  // Configuration Service - Singleton
-  container.register<IConfiguration>(
-    SERVICE_TOKENS.CONFIG,
-    () => createConfiguration(),
-    'singleton'
-  );
-
-  // Database Connection - Singleton
-  container.register<IDatabaseConnection>(
-    SERVICE_TOKENS.DATABASE,
-    async () => {
-      const dbClient = new MemoryDatabaseClient();
-      await dbClient.initialize();
-      return dbClient;
-    },
-    'singleton'
-  );
-
-  // Memory Storage - Singleton
-  container.register<IStorage>(
-    SERVICE_TOKENS.MEMORY_STORAGE,
-    async () => {
-      const storage = new SeparatedMemoryStorage();
-      await storage.initialize();
-      return storage;
-    },
-    'singleton'
-  );
-
-  // Search Service - Singleton
-  container.register<ISearchService>(
-    SERVICE_TOKENS.SEARCH_SERVICE,
-    async () => {
-      const searchService = getSearchService();
-      await searchService.initialize();
-      return searchService;
-    },
-    'singleton'
-  );
-
-  // Target Manager - Singleton
-  container.register<ITargetManager>(
-    SERVICE_TOKENS.TARGET_MANAGER,
-    () => targetManager,
-    'singleton'
-  );
-
-  // Embedding Provider - Singleton (lazy initialization)
-  container.register<IEmbeddingProvider>(
-    SERVICE_TOKENS.EMBEDDING_PROVIDER,
-    async () => {
-      try {
-        return await getDefaultEmbeddingProvider();
-      } catch (_error) {
-        // Return a fallback provider that doesn't require external dependencies
-        return createFallbackEmbeddingProvider();
-      }
-    },
-    'singleton'
-  );
-
-  // MCP Service - Transient (since it depends on target)
-  container.register<IMCPService>(
-    SERVICE_TOKENS.MCP_SERVICE,
-    (targetId: string) => {
-      const targetOption = targetManager.getTarget(targetId);
-      if (targetOption._tag === 'None') {
-        throw new Error(`Target not found: ${targetId}`);
-      }
-
-      const target = targetOption.value;
-      return createMCPService({ target });
-    },
-    'transient'
-  );
-}
-
-/**
- * Create a logger instance that adapts our Logger to the ILogger interface
- */
-function createLogger(): ILogger {
-  const logger = createRealLogger();
-
-  return {
-    info(message: string, ...args: any[]): void {
-      // Merge args into context for structured logging
-      const context = args.length > 0 ? { args } : undefined;
-      logger.info(message, context);
-    },
-
-    warn(message: string, ...args: any[]): void {
-      const context = args.length > 0 ? { args } : undefined;
-      logger.warn(message, context);
-    },
-
-    error(message: string, error?: Error | unknown, ...args: any[]): void {
-      const context = args.length > 0 ? { args } : undefined;
-      if (error instanceof Error) {
-        logger.error(message, error, context);
-      } else {
-        logger.error(message, undefined, { ...context, error });
-      }
-    },
-
-    debug(message: string, ...args: any[]): void {
-      const context = args.length > 0 ? { args } : undefined;
-      logger.debug(message, context);
-    },
-
-    success(message: string, ...args: any[]): void {
-      // Success is just info with different styling
-      const context = args.length > 0 ? { args, level: 'success' } : { level: 'success' };
-      logger.info(message, context);
-    },
-  };
-}
-
-/**
- * Create a configuration service
- */
-function createConfiguration(): IConfiguration {
-  const config = new Map<string, any>();
-
-  // Load environment variables
-  const loadEnvConfig = () => {
-    config.set('env', process.env.NODE_ENV || 'development');
-    config.set('debug', process.env.DEBUG === 'true');
-    config.set('logLevel', process.env.LOG_LEVEL || 'info');
-    config.set('databasePath', process.env.DATABASE_PATH || '.sylphx-flow/memory.db');
-    config.set('embeddings.provider', process.env.EMBEDDINGS_PROVIDER || 'local');
-    config.set(
-      'embeddings.dimension',
-      Number.parseInt(process.env.EMBEDDINGS_DIMENSION || '384', 10)
-    );
-  };
-
-  loadEnvConfig();
-
-  return {
-    get<T = any>(key: string, defaultValue?: T): T {
-      return config.get(key) ?? defaultValue;
-    },
-
-    getRequired<T = any>(key: string): T {
-      const value = config.get(key);
-      if (value === undefined) {
-        throw new Error(`Required configuration key missing: ${key}`);
-      }
-      return value;
-    },
-
-    has(key: string): boolean {
-      return config.has(key);
-    },
-
-    set(key: string, value: any): void {
-      config.set(key, value);
-    },
-
-    async reload(): Promise<void> {
-      config.clear();
-      loadEnvConfig();
-    },
-  };
-}
-
-/**
- * Create a fallback embedding provider for when external providers are unavailable
- */
-function createFallbackEmbeddingProvider(): IEmbeddingProvider {
-  return {
-    name: 'fallback-tfidf',
-    async embed(text: string): Promise<number[]> {
-      // Simple TF-IDF like fallback - just return a hash-based vector
-      const words = text.toLowerCase().split(/\s+/);
-      const vector = new Array(384).fill(0);
-
-      // Create a simple hash-based embedding
-      words.forEach((word, index) => {
-        const hash = simpleHash(word);
-        const index1 = hash % 384;
-        const index2 = (hash * 2) % 384;
-        vector[index1] = (index + 1) / words.length;
-        vector[index2] = (index + 1) / (words.length * 2);
-      });
-
-      return vector;
-    },
-
-    async isAvailable(): Promise<boolean> {
-      return true; // Always available as fallback
-    },
-  };
-}
-
-/**
- * Simple hash function for fallback embeddings
- */
-function simpleHash(str: string): number {
-  let hash = 0;
-  for (let i = 0; i < str.length; i++) {
-    const char = str.charCodeAt(i);
-    hash = (hash << 5) - hash + char;
-    hash &= hash; // Convert to 32-bit integer
-  }
-  return Math.abs(hash);
-}
-
-/**
- * Get a service from the container (convenience method)
- */
-export async function getService<T>(token: string): Promise<T> {
-  return await container.resolve<T>(token);
-}
-
-/**
- * Check if a service is registered (convenience method)
- */
-export function hasService(token: string): boolean {
-  return container.isRegistered(token);
-}

package/src/core/session-service.ts

@@ -1,121 +0,0 @@
-/**
- * Session Service
- * Centralized session management for headless mode
- * Uses database for persistence
- */
-
-import chalk from 'chalk';
-import { loadAIConfig, getConfiguredProviders } from '../config/ai-config.js';
-import type { ProviderId, ProviderConfig } from '../config/ai-config.js';
-import type { Session } from '../types/session.types.js';
-import { getProvider } from '../providers/index.js';
-import { fetchModels } from '../utils/ai-model-fetcher.js';
-import { getSessionRepository } from '../db/database.js';
-
-/**
- * Get default model for a provider
- * Priority: config default-model > first available model
- */
-export async function getDefaultModel(providerId: ProviderId, providerConfig: ProviderConfig): Promise<string | null> {
-  // Try config first
-  const configModel = providerConfig['default-model'] as string | undefined;
-  if (configModel) {
-    return configModel;
-  }
-
-  // Fetch first available model
-  try {
-    const models = await fetchModels(providerId, providerConfig);
-    return models[0]?.id || null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Get or create session for headless mode
- */
-export async function getOrCreateSession(continueSession: boolean): Promise<Session | null> {
-  const cwd = process.cwd();
-  const configResult = await loadAIConfig(cwd);
-
-  if (configResult._tag === 'Failure') {
-    console.error(chalk.red('✗ Failed to load AI config'));
-    return null;
-  }
-
-  const config = configResult.value;
-  const configuredProviders = await getConfiguredProviders(cwd);
-
-  if (configuredProviders.length === 0) {
-    console.error(chalk.yellow('\n⚠️  No AI provider configured\n'));
-    console.error(chalk.dim('Run: sylphx code (to configure AI)\n'));
-    return null;
-  }
-
-  const providerId = config.defaultProvider ?? configuredProviders[0];
-  if (!providerId) {
-    console.error(chalk.yellow('\n⚠️  No provider configured\n'));
-    return null;
-  }
-
-  const providerConfig = config.providers?.[providerId];
-  if (!providerConfig) {
-    console.error(chalk.yellow('\n⚠️  Provider not configured\n'));
-    return null;
-  }
-
-  // Check if provider is properly configured
-  const provider = getProvider(providerId);
-  if (!provider.isConfigured(providerConfig)) {
-    console.error(chalk.yellow(`\n⚠️  ${provider.name} is not properly configured\n`));
-    console.error(chalk.dim('Run: sylphx code (to configure AI)\n'));
-    return null;
-  }
-
-  // Get session repository
-  const repository = await getSessionRepository();
-
-  // Try to continue last session
-  if (continueSession) {
-    const lastSession = await repository.getLastSession();
-    if (lastSession) {
-      console.error(chalk.dim(`Continuing session: ${lastSession.id}`));
-      console.error(chalk.dim(`Messages: ${lastSession.messages.length}\n`));
-      return lastSession;
-    }
-    console.error(chalk.yellow('No previous session found, creating new one\n'));
-  }
-
-  // Get default model (last used or first available)
-  const modelName = await getDefaultModel(providerId, providerConfig);
-  if (!modelName) {
-    console.error(chalk.yellow('\n⚠️  No models available for this provider\n'));
-    return null;
-  }
-
-  // Create new session in database
-  return await repository.createSession(providerId, modelName);
-}
-
-/**
- * Show error message for models without tool support
- */
-export function showModelToolSupportError(): void {
-  console.error(chalk.red('\n✗ No text response received from model\n'));
-  console.error(
-    chalk.yellow('The model may have called tools but did not generate a final text response.')
-  );
-  console.error(
-    chalk.yellow('This usually means:\n')
-  );
-  console.error(chalk.dim('  • The current model does not fully support multi-step tool calling'));
-  console.error(chalk.dim('  • Some models can call tools but cannot process results and respond\n'));
-  console.error(chalk.green('Recommended models with full tool support:'));
-  console.error(chalk.green('  • anthropic/claude-3.5-sonnet'));
-  console.error(chalk.green('  • anthropic/claude-3.5-haiku'));
-  console.error(chalk.green('  • openai/gpt-4o'));
-  console.error(chalk.green('  • google/gemini-2.0-flash-exp\n'));
-  console.error(chalk.dim('💡 Tip: Ask questions that don\'t require tools, or switch to a model above'));
-  console.error(chalk.dim('To configure: Run `sylphx code` (TUI mode) then type /provider\n'));
-}

package/src/core/storage-factory.ts

@@ -1,115 +0,0 @@
-/**
- * Storage Factory - 簡化存儲工廠
- * Feature-first, composable approach
- */
-
-import type { StorageConfig } from '../interfaces/unified-storage.js';
-import { createStorage } from './unified-storage.js';
-import { logger } from '../utils/logger.js';
-
-/**
- * Storage configuration builders
- */
-export const StorageConfig = {
-  memory: (options?: Partial<StorageConfig>): StorageConfig => ({
-    type: 'memory',
-    ...options,
-  }),
-
-  cache: (options?: {
-    defaultTTL?: number;
-    maxCacheSize?: number;
-    storageDir?: string;
-  }): StorageConfig => ({
-    type: 'cache',
-    defaultTTL: options?.defaultTTL || 3600,
-    maxCacheSize: options?.maxCacheSize,
-    storageDir: options?.storageDir,
-  }),
-
-  vector: (options?: {
-    vectorDimensions?: number;
-    connectionString?: string;
-    storageDir?: string;
-  }): StorageConfig => ({
-    type: 'vector',
-    vectorDimensions: options?.vectorDimensions || 1536,
-    connectionString: options?.connectionString,
-    storageDir: options?.storageDir,
-  }),
-} as const;
-
-/**
- * Create storage from configuration
- */
-export async function createStorageFromConfig<T = unknown>(config: StorageConfig) {
-  try {
-    const storage = createStorage<T>(config);
-    await storage.initialize();
-    logger.info('Storage created successfully', { type: config.type });
-    return storage;
-  } catch (error) {
-    logger.error('Failed to create storage', { type: config.type, error });
-    throw error;
-  }
-}
-
-/**
- * Convenience functions for creating storage
- */
-export async function createMemoryStorage<T = unknown>(options?: Partial<StorageConfig>) {
-  return createStorageFromConfig<T>(StorageConfig.memory(options));
-}
-
-export async function createCacheStorage<T = unknown>(options?: {
-  defaultTTL?: number;
-  maxCacheSize?: number;
-  storageDir?: string;
-}) {
-  return createStorageFromConfig<T>(StorageConfig.cache(options));
-}
-
-export async function createVectorStorage<T = unknown>(options?: {
-  vectorDimensions?: number;
-  connectionString?: string;
-  storageDir?: string;
-}) {
-  return createStorageFromConfig<T>(StorageConfig.vector(options));
-}
-
-/**
- * Create storage from environment configuration
- */
-export async function createStorageFromEnv<T = unknown>(type?: string): Promise<any> {
-  const storageType = type || process.env.STORAGE_TYPE || 'memory';
-
-  const config: StorageConfig = { type: storageType as any };
-
-  // Load configuration from environment variables
-  const connectionString = process.env.STORAGE_CONNECTION_STRING;
-  if (connectionString) {
-    config.connectionString = connectionString;
-  }
-
-  const storageDir = process.env.STORAGE_DIR;
-  if (storageDir) {
-    config.storageDir = storageDir;
-  }
-
-  const defaultTTL = process.env.CACHE_DEFAULT_TTL;
-  if (defaultTTL) {
-    config.defaultTTL = Number.parseInt(defaultTTL, 10);
-  }
-
-  const maxCacheSize = process.env.CACHE_MAX_SIZE;
-  if (maxCacheSize) {
-    config.maxCacheSize = Number.parseInt(maxCacheSize, 10);
-  }
-
-  const vectorDimensions = process.env.VECTOR_DIMENSIONS;
-  if (vectorDimensions) {
-    config.vectorDimensions = Number.parseInt(vectorDimensions, 10);
-  }
-
-  return createStorageFromConfig<T>(config);
-}