@sylphx/flow 1.8.0 → 1.8.2

package/src/utils/database-errors.ts

@@ -1,140 +0,0 @@
-/**
- * Database Error Handling - Simplified System
- * Replaces complex error hierarchy with simplified database-specific errors
- */
-
-import {
-  AppError,
-  createDatabaseError,
-  createValidationError,
-  ErrorCategory,
-  ErrorHandler,
-  ErrorSeverity,
-  DatabaseError as SimplifiedDatabaseError,
-  ValidationError as SimplifiedValidationError,
-} from './simplified-errors.js';
-
-/**
- * Simplified Database Error with additional database context
- */
-export class DatabaseError extends SimplifiedDatabaseError {
-  constructor(
-    message: string,
-    operation?: string,
-    cause?: Error,
-    context?: Record<string, unknown>
-  ) {
-    super(message, operation, context?.query as string);
-    this.cause = cause;
-    if (context) {
-      this.context = { ...this.context, ...context };
-    }
-  }
-}
-
-/**
- * Database-specific validation error
- */
-export class ValidationError extends SimplifiedValidationError {
-  constructor(message: string, field: string, value?: unknown, cause?: Error) {
-    super(message, field, value);
-    this.cause = cause;
-  }
-}
-
-/**
- * Database connection error
- */
-export class ConnectionError extends AppError {
-  constructor(message: string, connectionDetails?: Record<string, unknown>, cause?: Error) {
-    super(
-      message,
-      'CONNECTION_ERROR',
-      ErrorCategory.NETWORK,
-      ErrorSeverity.HIGH,
-      connectionDetails,
-      cause
-    );
-    this.name = 'ConnectionError';
-  }
-}
-
-/**
- * Database migration error
- */
-export class MigrationError extends AppError {
-  public readonly migrationName?: string;
-
-  constructor(message: string, migrationName?: string, cause?: Error) {
-    super(
-      message,
-      'MIGRATION_ERROR',
-      ErrorCategory.DATABASE,
-      ErrorSeverity.HIGH,
-      { migrationName },
-      cause
-    );
-    this.migrationName = migrationName;
-    this.name = 'MigrationError';
-  }
-}
-
-/**
- * Execute database operation with comprehensive error handling
- */
-export async function executeOperation<T>(
-  operation: string,
-  fn: () => Promise<T>,
-  context?: Record<string, unknown>
-): Promise<T> {
-  const result = await ErrorHandler.execute(fn, { operation, ...context });
-
-  if (result.success) {
-    return result.data;
-  }
-
-  // Convert to appropriate database error type
-  if (result.error instanceof AppError) {
-    throw result.error;
-  }
-
-  // Unknown error - wrap in DatabaseError
-  throw createDatabaseError(result.error.message, operation, context?.query as string);
-}
-
-/**
- * Type guard functions for database errors
- */
-export function isDatabaseError(error: unknown): error is DatabaseError {
-  return error instanceof DatabaseError;
-}
-
-export function isValidationError(error: unknown): error is ValidationError {
-  return error instanceof ValidationError;
-}
-
-export function isConnectionError(error: unknown): error is ConnectionError {
-  return error instanceof ConnectionError;
-}
-
-export function isMigrationError(error: unknown): error is MigrationError {
-  return error instanceof MigrationError;
-}
-
-/**
- * Convenience functions for creating database errors
- */
-export const createMigrationError = (
-  message: string,
-  migrationName?: string,
-  cause?: Error
-): MigrationError => new MigrationError(message, migrationName, cause);
-
-export const createConnectionError = (
-  message: string,
-  connectionDetails?: Record<string, unknown>,
-  cause?: Error
-): ConnectionError => new ConnectionError(message, connectionDetails, cause);
-
-// Re-export for backward compatibility
-export { createDatabaseError, createValidationError, ErrorHandler, AppError };

package/src/utils/debug-logger.ts

@@ -1,49 +0,0 @@
-/**
- * Debug Logger
- * Uses industry-standard 'debug' package
- *
- * Usage:
- *   DEBUG=* bun ./packages/flow/src/index.ts              // All debug logs
- *   DEBUG=sylphx:* bun ...                                 // All sylphx namespaces
- *   DEBUG=sylphx:search:* bun ...                          // Search namespace
- *   (no DEBUG) bun ...                                     // No debug logs
- *
- * Examples:
- *   import { createLogger } from '../utils/debug-logger.js';
- *
- *   const log = createLogger('search:indexing');
- *   log('Indexing started:', filePath);
- *
- * Features from 'debug' package:
- *   - Color-coded namespaces
- *   - Timestamp support (DEBUG_COLORS=no for no color)
- *   - Wildcard matching (DEBUG=sylphx:*)
- *   - Conditional logging (no performance impact when disabled)
- *   - Industry standard (used by Express, Socket.io, etc.)
- */
-
-import debug from 'debug';
-
-/**
- * Create a logger for a specific namespace
- * Namespace will be prefixed with 'sylphx:'
- *
- * @example
- * const log = createLogger('search:indexing');
- * log('Indexing started:', filePath);
- *
- * // Enable with:
- * // DEBUG=sylphx:search:indexing bun ./packages/flow/src/index.ts
- */
-export function createLogger(namespace: string) {
-  return debug(`sylphx:${namespace}`);
-}
-
-/**
- * For backwards compatibility
- * @deprecated Use createLogger instead
- */
-export function debugLog(namespace: string, ...args: any[]) {
-  const log = debug(`sylphx:${namespace}`);
-  log(...args);
-}

package/src/utils/file-scanner.ts

@@ -1,259 +0,0 @@
-/**
- * File Scanner
- * Scan project files for @file auto-completion with caching
- */
-
-import { readdir, stat, readFile as fsReadFile, writeFile } from 'node:fs/promises';
-import { join, relative } from 'node:path';
-import { readFile } from 'node:fs/promises';
-import { homedir } from 'node:os';
-
-export interface FileInfo {
-  path: string;
-  relativePath: string;
-  size: number;
-}
-
-// Default ignore patterns
-const DEFAULT_IGNORE = [
-  'node_modules',
-  '.git',
-  'dist',
-  'build',
-  '.next',
-  '.vercel',
-  '.turbo',
-  'coverage',
-  '.cache',
-  '.sylphx',
-  'bun.lock',
-  'package-lock.json',
-  'yarn.lock',
-];
-
-/**
- * Load .gitignore patterns
- */
-async function loadGitignore(rootPath: string): Promise<Set<string>> {
-  const patterns = new Set<string>(DEFAULT_IGNORE);
-
-  try {
-    const gitignorePath = join(rootPath, '.gitignore');
-    const content = await readFile(gitignorePath, 'utf8');
-
-    // Parse gitignore file
-    for (const line of content.split('\n')) {
-      const trimmed = line.trim();
-      // Skip empty lines and comments
-      if (trimmed && !trimmed.startsWith('#')) {
-        // Remove trailing slashes
-        const pattern = trimmed.endsWith('/') ? trimmed.slice(0, -1) : trimmed;
-        patterns.add(pattern);
-      }
-    }
-  } catch {
-    // No .gitignore file, use defaults only
-  }
-
-  return patterns;
-}
-
-/**
- * Check if path should be ignored
- */
-function shouldIgnore(relativePath: string, patterns: Set<string>): boolean {
-  // Check if any part of the path matches ignore patterns
-  const parts = relativePath.split('/');
-
-  for (const pattern of patterns) {
-    // Exact match
-    if (relativePath === pattern) return true;
-
-    // Directory match
-    if (parts.includes(pattern)) return true;
-
-    // Glob pattern (basic support for *)
-    if (pattern.includes('*')) {
-      const regex = new RegExp('^' + pattern.replace(/\*/g, '.*') + '$');
-      if (regex.test(relativePath)) return true;
-    }
-  }
-
-  return false;
-}
-
-/**
- * Recursively scan directory for files (parallelized)
- */
-async function scanDirectory(
-  dirPath: string,
-  rootPath: string,
-  patterns: Set<string>,
-  results: FileInfo[] = []
-): Promise<FileInfo[]> {
-  try {
-    const entries = await readdir(dirPath, { withFileTypes: true });
-
-    // Separate files and directories for parallel processing
-    const files: typeof entries = [];
-    const directories: typeof entries = [];
-
-    for (const entry of entries) {
-      const fullPath = join(dirPath, entry.name);
-      const relativePath = relative(rootPath, fullPath);
-
-      // Skip ignored paths
-      if (shouldIgnore(relativePath, patterns)) {
-        continue;
-      }
-
-      if (entry.isDirectory()) {
-        directories.push(entry);
-      } else if (entry.isFile()) {
-        files.push(entry);
-      }
-    }
-
-    // Process files in parallel (no need to stat each one individually)
-    // Use entry.isFile() which we already know, skip stat() call for performance
-    const fileResults = files.map((entry) => {
-      const fullPath = join(dirPath, entry.name);
-      const relativePath = relative(rootPath, fullPath);
-      return {
-        path: fullPath,
-        relativePath,
-        size: 0, // We skip stat() for performance, size not critical for autocomplete
-      };
-    });
-    results.push(...fileResults);
-
-    // Process subdirectories in parallel
-    if (directories.length > 0) {
-      const subdirResults = await Promise.all(
-        directories.map((entry) => {
-          const fullPath = join(dirPath, entry.name);
-          return scanDirectory(fullPath, rootPath, patterns, []);
-        })
-      );
-
-      // Flatten results from all subdirectories
-      for (const subdirResult of subdirResults) {
-        results.push(...subdirResult);
-      }
-    }
-  } catch (error) {
-    // Skip directories we can't read
-  }
-
-  return results;
-}
-
-// Cache for scanned files
-const CACHE_DIR = join(homedir(), '.sylphx', 'cache');
-const CACHE_VERSION = 1;
-
-interface ScanCache {
-  version: number;
-  rootPath: string;
-  timestamp: number;
-  files: FileInfo[];
-}
-
-/**
- * Get cache file path for a project
- */
-function getCachePath(rootPath: string): string {
-  // Use hash of root path as cache filename
-  const hash = Buffer.from(rootPath).toString('base64').replace(/[/+=]/g, '_');
-  return join(CACHE_DIR, `filescan-${hash}.json`);
-}
-
-/**
- * Load cached file list if valid
- */
-async function loadCache(rootPath: string): Promise<FileInfo[] | null> {
-  try {
-    const cachePath = getCachePath(rootPath);
-    const content = await fsReadFile(cachePath, 'utf8');
-    const cache: ScanCache = JSON.parse(content);
-
-    // Validate cache
-    if (cache.version !== CACHE_VERSION || cache.rootPath !== rootPath) {
-      return null;
-    }
-
-    // Check if cache is still fresh (less than 5 minutes old)
-    const age = Date.now() - cache.timestamp;
-    const MAX_CACHE_AGE = 5 * 60 * 1000; // 5 minutes
-    if (age > MAX_CACHE_AGE) {
-      return null;
-    }
-
-    return cache.files;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Save file list to cache
- */
-async function saveCache(rootPath: string, files: FileInfo[]): Promise<void> {
-  try {
-    const cachePath = getCachePath(rootPath);
-    const cache: ScanCache = {
-      version: CACHE_VERSION,
-      rootPath,
-      timestamp: Date.now(),
-      files,
-    };
-
-    // Ensure cache directory exists
-    const { mkdir } = await import('node:fs/promises');
-    await mkdir(CACHE_DIR, { recursive: true });
-
-    // Write cache file
-    await writeFile(cachePath, JSON.stringify(cache), 'utf8');
-  } catch (error) {
-    // Ignore cache write errors
-    console.warn('Failed to write file scanner cache:', error);
-  }
-}
-
-/**
- * Scan project files with caching
- * Returns list of files respecting .gitignore
- */
-export async function scanProjectFiles(rootPath: string): Promise<FileInfo[]> {
-  // Try to load from cache first
-  const cached = await loadCache(rootPath);
-  if (cached) {
-    return cached;
-  }
-
-  // Cache miss or stale, scan filesystem
-  const patterns = await loadGitignore(rootPath);
-  const files = await scanDirectory(rootPath, rootPath, patterns);
-
-  // Sort by path for consistent ordering
-  files.sort((a, b) => a.relativePath.localeCompare(b.relativePath));
-
-  // Save to cache for next time
-  saveCache(rootPath, files).catch(() => {
-    // Ignore cache save errors
-  });
-
-  return files;
-}
-
-/**
- * Filter files by query string
- */
-export function filterFiles(files: FileInfo[], query: string): FileInfo[] {
-  if (!query) return files;
-
-  const lowerQuery = query.toLowerCase();
-  return files.filter((file) =>
-    file.relativePath.toLowerCase().includes(lowerQuery)
-  );
-}

package/src/utils/help.ts

@@ -1,20 +0,0 @@
-export function showDefaultHelp(): void {
-  console.log('🚀 Sylphx Flow CLI - Legacy project initialization and flow management');
-  console.log('=========================================');
-  console.log('');
-  console.log('Available commands:');
-  console.log('  init       Initialize project with Sylphx Flow');
-  console.log('  run        Run workflows and flows');
-  console.log('  codebase   Search and analyze codebase');
-  console.log('  knowledge  Manage knowledge base');
-  console.log('  hook       Load dynamic content for hooks');
-  console.log('');
-  console.log('Examples:');
-  console.log('  sylphx-flow init');
-  console.log('  sylphx-flow init --target claude-code');
-  console.log('  sylphx-flow run "your prompt"');
-  console.log('  sylphx-flow codebase search "function"');
-  console.log('  sylphx-flow knowledge search "React patterns"');
-  console.log('');
-  console.log('Run "sylphx-flow <command> --help" for more information about a command.');
-}

package/src/utils/immutable-cache.ts

@@ -1,106 +0,0 @@
-/**
- * Immutable Cache
- * Functional cache abstraction that returns new state on mutations
- */
-
-export interface CacheState<K, V> {
-  readonly entries: ReadonlyMap<K, V>;
-  readonly size: number;
-}
-
-/**
- * Create an empty cache state
- */
-export const createCache = <K, V>(): CacheState<K, V> => ({
-  entries: new Map(),
-  size: 0,
-});
-
-/**
- * Set a value in the cache, returning new cache state
- */
-export const cacheSet = <K, V>(cache: CacheState<K, V>, key: K, value: V): CacheState<K, V> => {
-  const newEntries = new Map(cache.entries);
-  newEntries.set(key, value);
-  return {
-    entries: newEntries,
-    size: newEntries.size,
-  };
-};
-
-/**
- * Get a value from the cache
- */
-export const cacheGet = <K, V>(cache: CacheState<K, V>, key: K): V | undefined => {
-  return cache.entries.get(key);
-};
-
-/**
- * Delete a key from the cache, returning new cache state
- */
-export const cacheDelete = <K, V>(cache: CacheState<K, V>, key: K): CacheState<K, V> => {
-  const newEntries = new Map(cache.entries);
-  newEntries.delete(key);
-  return {
-    entries: newEntries,
-    size: newEntries.size,
-  };
-};
-
-/**
- * Delete multiple keys matching a predicate, returning new cache state
- */
-export const cacheDeleteWhere = <K, V>(
-  cache: CacheState<K, V>,
-  predicate: (key: K, value: V) => boolean
-): CacheState<K, V> => {
-  const newEntries = new Map<K, V>();
-  for (const [key, value] of cache.entries) {
-    if (!predicate(key, value)) {
-      newEntries.set(key, value);
-    }
-  }
-  return {
-    entries: newEntries,
-    size: newEntries.size,
-  };
-};
-
-/**
- * Clear all entries from the cache, returning new cache state
- */
-export const cacheClear = <K, V>(): CacheState<K, V> => createCache();
-
-/**
- * Get all keys from the cache
- */
-export const cacheKeys = <K, V>(cache: CacheState<K, V>): K[] => {
-  return Array.from(cache.entries.keys());
-};
-
-/**
- * Enforce maximum cache size by removing oldest entries (FIFO)
- * Returns new cache state
- */
-export const cacheEnforceLimit = <K, V>(
-  cache: CacheState<K, V>,
-  maxSize: number
-): CacheState<K, V> => {
-  if (cache.size <= maxSize) {
-    return cache;
-  }
-
-  const entriesToRemove = cache.size - maxSize;
-  const keys = Array.from(cache.entries.keys());
-  const keysToRemove = keys.slice(0, entriesToRemove);
-
-  const newEntries = new Map(cache.entries);
-  for (const key of keysToRemove) {
-    newEntries.delete(key);
-  }
-
-  return {
-    entries: newEntries,
-    size: newEntries.size,
-  };
-};