@sylphx/flow 1.8.0 → 1.8.2

package/src/db/auto-migrate.ts

@@ -1,322 +0,0 @@
-/**
- * Auto Migration System
- * Automatically migrates from file-based to database on first app start
- *
- * Design:
- * 1. Check if database has sessions table
- * 2. If not → Run migrations automatically
- * 3. Check if JSON files exist but not in database
- * 4. If yes → Auto-migrate files to database
- * 5. Completely transparent to user
- */
-
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-import { readdir, mkdir, readFile as fsReadFile, unlink } from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import { createClient } from '@libsql/client';
-import { drizzle } from 'drizzle-orm/libsql';
-import { migrate } from 'drizzle-orm/libsql/migrator';
-import { sql } from 'drizzle-orm';
-import { SessionRepository } from './session-repository.js';
-import { loadSession } from '../utils/session-manager.js';
-import { findPackageRoot } from '../utils/paths.js';
-
-const SESSION_DIR = join(homedir(), '.sylphx', 'sessions');
-const DB_DIR = join(homedir(), '.sylphx-flow');
-const DB_PATH = join(DB_DIR, 'memory.db');
-const MIGRATION_FLAG = join(DB_DIR, '.session-migrated');
-
-export interface MigrationProgress {
-  total: number;
-  current: number;
-  status: string;
-}
-
-export type ProgressCallback = (progress: MigrationProgress) => void;
-
-/**
- * Check if JSON session files need migration to database
- * Returns true if there are JSON files that need to be migrated
- *
- * Note: Schema migrations are handled automatically by Drizzle's migrate()
- * We only need to check for JSON file migration here
- */
-async function needsFileMigration(db: any): Promise<boolean> {
-  try {
-    // Check if migration flag exists
-    if (existsSync(MIGRATION_FLAG)) {
-      // Already migrated - cleanup any remaining JSON files
-      await cleanupOldJSONFiles();
-      return false;
-    }
-
-    // Check if JSON files exist that need migration
-    try {
-      const files = await readdir(SESSION_DIR);
-      const sessionFiles = files.filter((f) => f.endsWith('.json') && !f.startsWith('.'));
-
-      if (sessionFiles.length === 0) {
-        return false; // No files to migrate
-      }
-
-      // Check if any files not in database
-      const repository = new SessionRepository(db);
-      const dbCount = await repository.getSessionCount();
-
-      // If database is empty but files exist, need migration
-      return dbCount === 0 && sessionFiles.length > 0;
-    } catch {
-      return false; // Session directory doesn't exist
-    }
-  } catch {
-    return false;
-  }
-}
-
-/**
- * Cleanup old JSON files after migration
- * Called when migration flag exists (already migrated)
- */
-async function cleanupOldJSONFiles(): Promise<void> {
-  try {
-    const files = await readdir(SESSION_DIR);
-    const sessionFiles = files.filter((f) => f.endsWith('.json') && !f.startsWith('.'));
-
-    if (sessionFiles.length === 0) {
-      return; // No files to cleanup
-    }
-
-    console.log(`Cleaning up ${sessionFiles.length} old JSON files...`);
-    let deletedCount = 0;
-
-    for (const file of sessionFiles) {
-      try {
-        await unlink(join(SESSION_DIR, file));
-        deletedCount++;
-      } catch (error) {
-        console.warn(`Failed to delete ${file}:`, error);
-      }
-    }
-
-    console.log(`Cleanup complete: deleted ${deletedCount}/${sessionFiles.length} JSON files`);
-  } catch {
-    // Session directory doesn't exist or other error - ignore
-  }
-}
-
-/**
- * Run database schema migrations
- */
-async function runSchemaMigrations(db: any): Promise<void> {
-  // Ensure database directory exists
-  await mkdir(DB_DIR, { recursive: true });
-
-  // Run Drizzle migrations using package root to find migrations
-  // This works with npm global install
-  const packageRoot = findPackageRoot('drizzle migrations');
-  const migrationsPath = join(packageRoot, 'drizzle');
-
-  if (!existsSync(migrationsPath)) {
-    throw new Error(`Drizzle migrations not found at ${migrationsPath}`);
-  }
-
-  await migrate(db, { migrationsFolder: migrationsPath });
-}
-
-/**
- * Migrate session files to database
- */
-async function migrateSessionFiles(
-  db: any,
-  onProgress?: ProgressCallback
-): Promise<{ success: number; errors: number }> {
-  const repository = new SessionRepository(db);
-
-  // Get all session files
-  const files = await readdir(SESSION_DIR);
-  const sessionFiles = files.filter((f) => f.endsWith('.json') && !f.startsWith('.'));
-
-  let successCount = 0;
-  let errorCount = 0;
-
-  onProgress?.({
-    total: sessionFiles.length,
-    current: 0,
-    status: `Found ${sessionFiles.length} sessions to migrate`,
-  });
-
-  for (let i = 0; i < sessionFiles.length; i++) {
-    const file = sessionFiles[i];
-    const sessionId = file.replace('.json', '');
-
-    try {
-      onProgress?.({
-        total: sessionFiles.length,
-        current: i + 1,
-        status: `Migrating session ${i + 1}/${sessionFiles.length}`,
-      });
-
-      // Load session from file
-      const session = await loadSession(sessionId);
-
-      if (!session) {
-        errorCount++;
-        continue;
-      }
-
-      // Check if already exists
-      const existing = await repository.getSessionById(session.id);
-      if (existing) {
-        continue; // Skip duplicates
-      }
-
-      // Create session in database with existing ID and metadata
-      await repository.createSessionFromData({
-        id: session.id,
-        provider: session.provider,
-        model: session.model,
-        title: session.title,
-        nextTodoId: session.nextTodoId || 1,
-        created: session.created,
-        updated: session.updated,
-      });
-
-      // Add all messages
-      // Normalize attachments from old JSON files (might have corrupt data like {})
-      for (const message of session.messages) {
-        // Normalize attachments: must be array or undefined
-        let normalizedAttachments: typeof message.attachments = undefined;
-        if (message.attachments && Array.isArray(message.attachments) && message.attachments.length > 0) {
-          const validAttachments = message.attachments.filter((a: any) =>
-            a && typeof a === 'object' && a.path && a.relativePath
-          );
-          if (validAttachments.length > 0) {
-            normalizedAttachments = validAttachments;
-          }
-        }
-
-        await repository.addMessage(
-          session.id,
-          message.role,
-          message.content,
-          normalizedAttachments,
-          message.usage,
-          message.finishReason,
-          message.metadata,
-          message.todoSnapshot
-        );
-      }
-
-      // Update todos
-      if (session.todos && session.todos.length > 0) {
-        await repository.updateTodos(session.id, session.todos, session.nextTodoId);
-      }
-
-      // Migration successful - delete the JSON file to free space and avoid confusion
-      const filePath = join(SESSION_DIR, file);
-      try {
-        await unlink(filePath);
-      } catch (unlinkError) {
-        console.warn(`Successfully migrated ${sessionId} but failed to delete JSON file:`, unlinkError);
-      }
-
-      successCount++;
-    } catch (error) {
-      console.error(`Error migrating ${sessionId}:`, error);
-      errorCount++;
-      // Keep JSON file on error for debugging
-    }
-  }
-
-  // Create migration flag
-  await fsReadFile(MIGRATION_FLAG, 'utf8').catch(() =>
-    require('fs').writeFileSync(MIGRATION_FLAG, new Date().toISOString())
-  );
-
-  return { success: successCount, errors: errorCount };
-}
-
-/**
- * Auto-migrate on app startup
- * Returns database instance ready to use
- *
- * Design: Always run schema migrations (Drizzle handles detection)
- * 1. Run Drizzle migrate() - automatically applies only new migrations
- * 2. Check and migrate JSON files if needed
- */
-export async function autoMigrate(onProgress?: ProgressCallback): Promise<any> {
-  const DATABASE_URL = process.env.DATABASE_URL || `file:${DB_PATH}`;
-
-  // Initialize database with optimized settings for concurrency
-  const client = createClient({ url: DATABASE_URL });
-  const db = drizzle(client);
-
-  // Configure SQLite for better concurrency
-  // WAL mode allows concurrent reads while writing
-  // Busy timeout retries when database is locked (5 seconds)
-  await client.execute('PRAGMA journal_mode = WAL');
-  await client.execute('PRAGMA busy_timeout = 5000');
-  await client.execute('PRAGMA synchronous = NORMAL');
-
-  onProgress?.({
-    total: 2,
-    current: 0,
-    status: 'Running database migrations...',
-  });
-
-  // Always run schema migrations
-  // Drizzle's migrate() automatically detects and applies only new migrations
-  await runSchemaMigrations(db);
-
-  onProgress?.({
-    total: 2,
-    current: 1,
-    status: 'Database schema up to date',
-  });
-
-  // Check if JSON file migration needed
-  const needsFiles = await needsFileMigration(db);
-
-  if (needsFiles) {
-    try {
-      const files = await readdir(SESSION_DIR);
-      const sessionFiles = files.filter((f) => f.endsWith('.json') && !f.startsWith('.'));
-
-      if (sessionFiles.length > 0) {
-        onProgress?.({
-          total: 2 + sessionFiles.length,
-          current: 1,
-          status: `Migrating ${sessionFiles.length} sessions from files...`,
-        });
-
-        // Migrate files to database
-        const result = await migrateSessionFiles(db, (fileProgress) => {
-          onProgress?.({
-            total: 2 + fileProgress.total,
-            current: 1 + fileProgress.current,
-            status: fileProgress.status,
-          });
-        });
-
-        onProgress?.({
-          total: 2 + sessionFiles.length,
-          current: 2 + sessionFiles.length,
-          status: `Migration complete! ${result.success} sessions migrated`,
-        });
-      }
-    } catch {
-      // No session directory, skip file migration
-    }
-  }
-
-  return db;
-}
-
-/**
- * Initialize database with auto-migration
- * Call this on app startup
- */
-export async function initializeDatabase(onProgress?: ProgressCallback): Promise<any> {
-  return autoMigrate(onProgress);
-}

package/src/db/base-database-client.ts

@@ -1,144 +0,0 @@
-/**
- * Base database client - 基礎數據庫客戶端
- * 提供共用的數據庫連接和管理功能
- */
-
-import * as fs from 'node:fs';
-import * as path from 'node:path';
-import { createClient } from '@libsql/client';
-import { drizzle } from 'drizzle-orm/libsql';
-import { ConnectionError, DatabaseError } from '../utils/database-errors.js';
-
-export abstract class BaseDatabaseClient<TSchema extends Record<string, unknown>> {
-  protected client: ReturnType<typeof createClient>;
-  public db: ReturnType<typeof drizzle<TSchema>>;
-  protected dbName: string;
-
-  constructor(dbName: string, schema: TSchema) {
-    this.dbName = dbName;
-
-    try {
-      const dbDir = path.join(process.cwd(), '.sylphx-flow');
-
-      // Ensure directory exists with proper error handling
-      try {
-        if (!fs.existsSync(dbDir)) {
-          fs.mkdirSync(dbDir, { recursive: true });
-        }
-      } catch (dirError) {
-        throw new Error(
-          `Failed to create database directory: ${dbDir}. ` +
-          `Error: ${(dirError as Error).message}`
-        );
-      }
-
-      const dbPath = path.join(dbDir, `${dbName}.db`);
-
-      // Use local path directly without file: URL scheme
-      // libSQL will automatically create the file if it doesn't exist
-      this.client = createClient({
-        url: dbPath,
-      });
-
-      this.db = drizzle(this.client, { schema });
-    } catch (error) {
-      const dbPath = path.join(process.cwd(), '.sylphx-flow', `${dbName}.db`);
-
-      throw new ConnectionError(
-        `Failed to initialize ${dbName} database connection`,
-        {
-          url: dbPath,
-          dbPath,
-          cwd: process.cwd(),
-          platform: process.platform,
-        },
-        error as Error
-      );
-    }
-  }
-
-  /**
-   * Initialize database schema - 子類必須實現
-   */
-  abstract initialize(): Promise<void>;
-
-  /**
-   * Get migration status - 子類必須實現
-   */
-  abstract getMigrationStatus(): Promise<{
-    isMigrated: boolean;
-    migrationCount: number;
-  }>;
-
-  /**
-   * Perform database health check - 子類必須實現
-   */
-  abstract healthCheck(): Promise<{
-    healthy: boolean;
-    error?: string;
-    details?: Record<string, unknown>;
-  }>;
-
-  /**
-   * Close database connection
-   */
-  async close(): Promise<void> {
-    // libSQL client doesn't have explicit close for file-based databases
-  }
-
-  /**
-   * Get database path for debugging
-   */
-  getDatabasePath(): string {
-    return path.join(process.cwd(), '.sylphx-flow', `${this.dbName}.db`);
-  }
-
-  /**
-   * Create tables directly with common pattern
-   */
-  protected async createTable(definition: string): Promise<void> {
-    try {
-      await this.client.execute(definition);
-    } catch (error) {
-      throw new DatabaseError(
-        `Failed to create table for ${this.dbName}`,
-        `${this.dbName}.createTable`,
-        error as Error
-      );
-    }
-  }
-
-  /**
-   * Create index with common pattern
-   */
-  protected async createIndex(definition: string): Promise<void> {
-    try {
-      await this.client.execute(definition);
-    } catch (error) {
-      throw new DatabaseError(
-        `Failed to create index for ${this.dbName}`,
-        `${this.dbName}.createIndex`,
-        error as Error
-      );
-    }
-  }
-
-  /**
-   * Check if table exists
-   */
-  protected async tableExists(tableName: string): Promise<boolean> {
-    try {
-      const result = await this.client.execute(`
-        SELECT name FROM sqlite_master 
-        WHERE type='table' AND name='${tableName}'
-      `);
-      return result.rows.length > 0;
-    } catch (error) {
-      throw new DatabaseError(
-        `Failed to check if table ${tableName} exists`,
-        `${this.dbName}.tableExists`,
-        error as Error
-      );
-    }
-  }
-}

package/src/db/cache-db.ts

@@ -1,218 +0,0 @@
-/**
- * Cache database client - 臨時索引數據庫
- * 負責管理可以重新生成的緩存數據（代碼索引、搜索詞彙等）
- */
-
-import * as path from 'node:path';
-import type { drizzle } from 'drizzle-orm/libsql';
-import { DatabaseError } from '../utils/database-errors.js';
-import { BaseDatabaseClient } from './base-database-client.js';
-import * as schema from './cache-schema.js';
-
-export type CacheDatabase = ReturnType<typeof drizzle<typeof schema>>;
-
-export class CacheDatabaseClient extends BaseDatabaseClient<typeof schema> {
-  constructor() {
-    super('cache', schema);
-  }
-
-  /**
-   * Initialize cache database schema
-   */
-  async initialize(): Promise<void> {
-    try {
-      // Check if tables already exist
-      const migrationStatus = await this.getMigrationStatus();
-
-      if (migrationStatus.isMigrated) {
-        // Tables already exist, skip logging to reduce noise
-        return;
-      }
-
-      // For now, create tables directly since we don't have migration files yet
-      await this.createTables();
-      console.error('[INFO] Cache database tables created');
-    } catch (error) {
-      throw new DatabaseError(
-        'Failed to initialize cache database',
-        'cache.initialize',
-        error as Error
-      );
-    }
-  }
-
-  /**
-   * Create tables directly (fallback)
-   */
-  private async createTables(): Promise<void> {
-    // Create codebase_files table
-    await this.createTable(`
-      CREATE TABLE IF NOT EXISTS codebase_files_table (
-        path TEXT PRIMARY KEY,
-        mtime INTEGER NOT NULL,
-        hash TEXT NOT NULL,
-        content TEXT,
-        language TEXT,
-        size INTEGER,
-        indexed_at TEXT NOT NULL
-      )
-    `);
-
-    // Create codebase_metadata table
-    await this.createTable(`
-      CREATE TABLE IF NOT EXISTS codebase_metadata_table (
-        key TEXT PRIMARY KEY,
-        value TEXT NOT NULL
-      )
-    `);
-
-    // Create tfidf_documents table
-    await this.createTable(`
-      CREATE TABLE IF NOT EXISTS tfidf_documents_table (
-        file_path TEXT PRIMARY KEY,
-        magnitude REAL NOT NULL,
-        term_count INTEGER NOT NULL,
-        raw_terms TEXT NOT NULL,
-        FOREIGN KEY (file_path) REFERENCES codebase_files_table(path) ON DELETE CASCADE
-      )
-    `);
-
-    // Create tfidf_idf table
-    await this.createTable(`
-      CREATE TABLE IF NOT EXISTS tfidf_idf_table (
-        term TEXT PRIMARY KEY,
-        idf_value REAL NOT NULL
-      )
-    `);
-
-    // Create tfidf_terms table
-    await this.createTable(`
-      CREATE TABLE IF NOT EXISTS tfidf_terms_table (
-        file_path TEXT NOT NULL,
-        term TEXT NOT NULL,
-        frequency REAL NOT NULL,
-        PRIMARY KEY (file_path, term),
-        FOREIGN KEY (file_path) REFERENCES codebase_files_table(path) ON DELETE CASCADE
-      )
-    `);
-
-    // Create indexes
-    await this.createIndex(`
-      CREATE INDEX IF NOT EXISTS idx_codebase_files_mtime ON codebase_files_table (mtime)
-    `);
-
-    await this.createIndex(`
-      CREATE INDEX IF NOT EXISTS idx_codebase_files_hash ON codebase_files_table (hash)
-    `);
-
-    await this.createIndex(`
-      CREATE INDEX IF NOT EXISTS idx_tfidf_terms_term ON tfidf_terms_table (term)
-    `);
-
-    await this.createIndex(`
-      CREATE INDEX IF NOT EXISTS idx_tfidf_terms_file ON tfidf_terms_table (file_path)
-    `);
-  }
-
-  /**
-   * Get migration status
-   */
-  async getMigrationStatus(): Promise<{
-    isMigrated: boolean;
-    migrationCount: number;
-  }> {
-    try {
-      const tables = ['codebase_files_table', 'tfidf_terms_table', 'tfidf_documents_table'];
-      let existingCount = 0;
-
-      for (const table of tables) {
-        if (await this.tableExists(table)) {
-          existingCount++;
-        }
-      }
-
-      return {
-        isMigrated: existingCount >= 2, // At least codebase_files and tfidf_terms
-        migrationCount: existingCount,
-      };
-    } catch (error) {
-      throw new DatabaseError(
-        'Failed to check cache database migration status',
-        'cache.getMigrationStatus',
-        error as Error
-      );
-    }
-  }
-
-  /**
-   * Clear all cache data (useful for rebuilding)
-   */
-  async clearCache(): Promise<void> {
-    try {
-      await this.client.execute('DELETE FROM tfidf_terms_table');
-      await this.client.execute('DELETE FROM tfidf_documents_table');
-      await this.client.execute('DELETE FROM tfidf_idf_table');
-      await this.client.execute('DELETE FROM codebase_files_table');
-      await this.client.execute('DELETE FROM codebase_metadata_table');
-
-      console.error('[INFO] Cache database cleared');
-    } catch (error) {
-      throw new DatabaseError('Failed to clear cache database', 'cache.clearCache', error as Error);
-    }
-  }
-
-  /**
-   * Perform database health check
-   */
-  async healthCheck(): Promise<{
-    healthy: boolean;
-    error?: string;
-    details?: Record<string, unknown>;
-  }> {
-    try {
-      // Test basic connectivity
-      await this.client.execute('SELECT 1');
-
-      // Check if cache tables exist
-      const migrationStatus = await this.getMigrationStatus();
-
-      // Test basic read/write operation
-      const testResult = await this.client.execute(`
-        SELECT count(*) as count FROM codebase_files_table
-      `);
-
-      return {
-        healthy: true,
-        details: {
-          tablesExist: migrationStatus.isMigrated,
-          tableCount: migrationStatus.migrationCount,
-          cachedFiles: testResult.rows[0]?.count || 0,
-        },
-      };
-    } catch (error) {
-      return {
-        healthy: false,
-        error: (error as Error).message,
-      };
-    }
-  }
-
-  /**
-   * Close database connection
-   */
-  async close(): Promise<void> {
-    // libSQL client doesn't have explicit close for file-based databases
-  }
-
-  /**
-   * Get database path for debugging
-   */
-  getDatabasePath(): string {
-    const cacheDir = path.join(process.cwd(), '.sylphx-flow');
-    return path.join(cacheDir, 'cache.db');
-  }
-}
-
-// Export schema and types
-export * from './cache-schema.js';
-export { schema };