@sylphx/flow 1.0.1 → 1.0.3

package/src/core/rule-manager.ts

@@ -0,0 +1,240 @@
+/**
+ * Rule Manager
+ * Manages rule state and operations
+ */
+
+import type { Rule } from '../types/rule.types.js';
+import { loadAllRules } from './rule-loader.js';
+
+/**
+ * Rule manager state
+ */
+interface RuleManagerState {
+  rules: Map<string, Rule>;
+  cwd: string;
+}
+
+let state: RuleManagerState | null = null;
+
+/**
+ * Get the app store (lazy import to avoid circular dependencies)
+ */
+let getAppStore: (() => any) | null = null;
+
+/**
+ * Set the app store getter (called during initialization)
+ */
+export function setRuleAppStoreGetter(getter: () => any): void {
+  getAppStore = getter;
+}
+
+/**
+ * Initialize rule manager
+ */
+export async function initializeRuleManager(cwd: string): Promise<void> {
+  const allRules = await loadAllRules(cwd);
+
+  const ruleMap = new Map<string, Rule>();
+  for (const rule of allRules) {
+    ruleMap.set(rule.id, rule);
+  }
+
+  state = {
+    rules: ruleMap,
+    cwd,
+  };
+
+  // Initialize store with default enabled rules
+  if (getAppStore) {
+    const store = getAppStore();
+    if (store.getState) {
+      const currentEnabledRules = store.getState().enabledRuleIds || [];
+
+      // If no rules are enabled yet, enable all rules that have enabled: true in metadata
+      if (currentEnabledRules.length === 0) {
+        const defaultEnabledRules = allRules
+          .filter((rule) => rule.metadata.enabled !== false)
+          .map((rule) => rule.id);
+
+        if (defaultEnabledRules.length > 0) {
+          store.getState().setEnabledRuleIds(defaultEnabledRules);
+        }
+      }
+    }
+  }
+}
+
+/**
+ * Get all available rules
+ */
+export function getAllRules(): Rule[] {
+  if (!state) {
+    return [];
+  }
+  return Array.from(state.rules.values());
+}
+
+/**
+ * Get rule by ID
+ */
+export function getRuleById(id: string): Rule | null {
+  if (!state) {
+    return null;
+  }
+  return state.rules.get(id) || null;
+}
+
+/**
+ * Get enabled rule IDs from store
+ */
+export function getEnabledRuleIds(): string[] {
+  if (getAppStore) {
+    const store = getAppStore();
+    if (store.getState) {
+      return store.getState().enabledRuleIds || [];
+    }
+  }
+  return [];
+}
+
+/**
+ * Get enabled rules
+ */
+export function getEnabledRules(): Rule[] {
+  if (!state) {
+    return [];
+  }
+
+  const enabledIds = getEnabledRuleIds();
+  return enabledIds
+    .map((id) => state!.rules.get(id))
+    .filter((rule): rule is Rule => rule !== null);
+}
+
+/**
+ * Toggle a rule on/off
+ */
+export function toggleRule(ruleId: string): boolean {
+  if (!state || !state.rules.has(ruleId)) {
+    return false;
+  }
+
+  if (getAppStore) {
+    const store = getAppStore();
+    if (store.getState) {
+      const currentEnabled = store.getState().enabledRuleIds || [];
+
+      if (currentEnabled.includes(ruleId)) {
+        // Disable: remove from list
+        store.getState().setEnabledRuleIds(currentEnabled.filter((id) => id !== ruleId));
+      } else {
+        // Enable: add to list
+        store.getState().setEnabledRuleIds([...currentEnabled, ruleId]);
+      }
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Enable a rule
+ */
+export function enableRule(ruleId: string): boolean {
+  if (!state || !state.rules.has(ruleId)) {
+    return false;
+  }
+
+  if (getAppStore) {
+    const store = getAppStore();
+    if (store.getState) {
+      const currentEnabled = store.getState().enabledRuleIds || [];
+
+      if (!currentEnabled.includes(ruleId)) {
+        store.getState().setEnabledRuleIds([...currentEnabled, ruleId]);
+      }
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Disable a rule
+ */
+export function disableRule(ruleId: string): boolean {
+  if (!state || !state.rules.has(ruleId)) {
+    return false;
+  }
+
+  if (getAppStore) {
+    const store = getAppStore();
+    if (store.getState) {
+      const currentEnabled = store.getState().enabledRuleIds || [];
+      store.getState().setEnabledRuleIds(currentEnabled.filter((id) => id !== ruleId));
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Reload rules from disk
+ */
+export async function reloadRules(): Promise<void> {
+  if (!state) {
+    return;
+  }
+
+  const cwd = state.cwd;
+  const currentEnabled = getEnabledRuleIds();
+
+  await initializeRuleManager(cwd);
+
+  // Keep only enabled rules that still exist
+  if (state && getAppStore) {
+    const store = getAppStore();
+    if (store.getState) {
+      const validEnabled = currentEnabled.filter((id) => state!.rules.has(id));
+      store.getState().setEnabledRuleIds(validEnabled);
+    }
+  }
+}
+
+/**
+ * Set enabled rules (replaces current enabled rules)
+ */
+export function setEnabledRules(ruleIds: string[]): boolean {
+  if (!state) {
+    return false;
+  }
+
+  // Validate all rule IDs exist
+  const validRuleIds = ruleIds.filter((id) => state!.rules.has(id));
+
+  if (getAppStore) {
+    const store = getAppStore();
+    if (store.getState) {
+      store.getState().setEnabledRuleIds(validRuleIds);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Get combined content of all enabled rules
+ */
+export function getEnabledRulesContent(): string {
+  const enabledRules = getEnabledRules();
+
+  if (enabledRules.length === 0) {
+    return '';
+  }
+
+  return enabledRules.map((rule) => rule.content).join('\n\n');
+}

package/src/core/service-config.ts

@@ -0,0 +1,252 @@
+/**
+ * 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

@@ -0,0 +1,121 @@
+/**
+ * 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'));
+}