@sylphx/flow 1.7.0 → 1.8.1

package/src/db/cache-schema.ts

@@ -1,75 +0,0 @@
-/**
- * Cache database schema - 臨時索引數據 (不應該上 Git)
- * 包含代碼庫索引、搜索詞彙等可以重新生成的數據
- */
-
-import { index, integer, primaryKey, real, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-
-// Codebase files table (代碼庫檔案索引)
-export const codebaseFiles = sqliteTable(
-  'codebase_files_table',
-  {
-    path: text('path').primaryKey(),
-    mtime: integer('mtime').notNull(),
-    hash: text('hash').notNull(),
-    content: text('content'), // Optional full content
-    language: text('language'), // Detected programming language
-    size: integer('size'), // File size in bytes
-    indexedAt: text('indexed_at').notNull(),
-  },
-  (table) => [
-    index('idx_codebase_files_mtime').on(table.mtime),
-    index('idx_codebase_files_hash').on(table.hash),
-  ]
-);
-
-// Codebase metadata table (代碼庫元數據)
-export const codebaseMetadata = sqliteTable('codebase_metadata_table', {
-  key: text('key').primaryKey(),
-  value: text('value').notNull(),
-});
-
-// TF-IDF terms table (搜索詞彙)
-export const tfidfTerms = sqliteTable(
-  'tfidf_terms_table',
-  {
-    filePath: text('file_path')
-      .notNull()
-      .references(() => codebaseFiles.path, { onDelete: 'cascade' }),
-    term: text('term').notNull(),
-    frequency: real('frequency').notNull(),
-  },
-  (table) => [
-    primaryKey({ columns: [table.filePath, table.term] }),
-    index('idx_tfidf_terms_term').on(table.term),
-    index('idx_tfidf_terms_file').on(table.filePath),
-  ]
-);
-
-// TF-IDF documents table (文檔向量)
-export const tfidfDocuments = sqliteTable('tfidf_documents_table', {
-  filePath: text('file_path')
-    .primaryKey()
-    .references(() => codebaseFiles.path, { onDelete: 'cascade' }),
-  magnitude: real('magnitude').notNull(),
-  termCount: integer('term_count').notNull(),
-  rawTerms: text('raw_terms').notNull(), // JSON string
-});
-
-// TF-IDF IDF values table (IDF 計算結果)
-export const tfidfIdf = sqliteTable('tfidf_idf_table', {
-  term: text('term').primaryKey(),
-  idfValue: real('idf_value').notNull(),
-});
-
-// Types for cache database
-export type CodebaseFile = typeof codebaseFiles.$inferSelect;
-export type NewCodebaseFile = typeof codebaseFiles.$inferInsert;
-export type CodebaseMetadata = typeof codebaseMetadata.$inferSelect;
-export type NewCodebaseMetadata = typeof codebaseMetadata.$inferInsert;
-export type TfidfTerm = typeof tfidfTerms.$inferSelect;
-export type NewTfidfTerm = typeof tfidfTerms.$inferInsert;
-export type TfidfDocument = typeof tfidfDocuments.$inferSelect;
-export type NewTfidfDocument = typeof tfidfDocuments.$inferInsert;
-export type TfidfIdf = typeof tfidfIdf.$inferSelect;
-export type NewTfidfIdf = typeof tfidfIdf.$inferInsert;

package/src/db/database.ts

@@ -1,70 +0,0 @@
-/**
- * Database Singleton
- * Global database instance and repository access
- */
-
-import { createClient } from '@libsql/client';
-import { drizzle } from 'drizzle-orm/libsql';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-import { SessionRepository } from './session-repository.js';
-import { initializeDatabase } from './auto-migrate.js';
-
-const DB_PATH = join(homedir(), '.sylphx-flow', 'memory.db');
-const DATABASE_URL = process.env.DATABASE_URL || `file:${DB_PATH}`;
-
-// Global database instance
-let dbInstance: any = null;
-let repositoryInstance: SessionRepository | null = null;
-let initPromise: Promise<any> | null = null;
-
-/**
- * Get database instance (lazy initialization with auto-migration)
- * Ensures database is initialized only once
- */
-export async function getDatabase(): Promise<any> {
-  if (dbInstance) {
-    return dbInstance;
-  }
-
-  // If initialization in progress, wait for it
-  if (initPromise) {
-    return initPromise;
-  }
-
-  // Start initialization
-  initPromise = initializeDatabase((progress) => {
-    if (process.env.DEBUG) {
-      console.log(`[DB] ${progress.current}/${progress.total}: ${progress.status}`);
-    }
-  });
-
-  dbInstance = await initPromise;
-  initPromise = null;
-
-  return dbInstance;
-}
-
-/**
- * Get session repository instance
- * Ensures repository uses initialized database
- */
-export async function getSessionRepository(): Promise<SessionRepository> {
-  if (repositoryInstance) {
-    return repositoryInstance;
-  }
-
-  const db = await getDatabase();
-  repositoryInstance = new SessionRepository(db);
-
-  return repositoryInstance;
-}
-
-/**
- * Reset database instance (for testing)
- */
-export function resetDatabase(): void {
-  dbInstance = null;
-  repositoryInstance = null;
-  initPromise = null;
-}

package/src/db/index.ts

@@ -1,252 +0,0 @@
-/**
- * Drizzle ORM database client for Sylphx Flow
- * Type-safe database operations with proper migrations
- */
-
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { createClient } from '@libsql/client';
-import { drizzle } from 'drizzle-orm/libsql';
-import { migrate } from 'drizzle-orm/libsql/migrator';
-import { ConnectionError, DatabaseError } from '../utils/database-errors.js';
-import * as schema from './schema.js';
-import { findPackageRoot } from '../utils/paths.js';
-
-export type Database = ReturnType<typeof drizzle<typeof schema>>;
-
-export class DrizzleDatabase {
-  private client: ReturnType<typeof createClient>;
-  public db: Database;
-  private useHomeDir: boolean;
-
-  constructor(options?: { useHomeDir?: boolean }) {
-    // Default to project directory if not specified
-    this.useHomeDir = options?.useHomeDir ?? false;
-
-    try {
-      // Create both home directory and current directory .sylphx-flow folders
-      const homeDir = path.join(os.homedir(), '.sylphx-flow');
-      const projectDir = path.join(process.cwd(), '.sylphx-flow');
-
-      // Ensure both directories exist with proper error handling
-      try {
-        if (!fs.existsSync(homeDir)) {
-          fs.mkdirSync(homeDir, { recursive: true });
-        }
-        if (!fs.existsSync(projectDir)) {
-          fs.mkdirSync(projectDir, { recursive: true });
-        }
-      } catch (dirError) {
-        throw new Error(
-          `Failed to create database directories: ${homeDir}, ${projectDir}. ` +
-          `Error: ${(dirError as Error).message}`
-        );
-      }
-
-      // Determine database location
-      // code command uses home directory, init/run commands use project directory
-      const memoryDir = this.useHomeDir ? homeDir : projectDir;
-      const dbPath = path.join(memoryDir, 'memory.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', 'memory.db');
-
-      throw new ConnectionError(
-        'Failed to initialize database connection',
-        {
-          url: dbPath,
-          dbPath,
-          cwd: process.cwd(),
-          platform: process.platform,
-        },
-        error as Error
-      );
-    }
-  }
-
-  /**
-   * Initialize database schema using Drizzle migrations
-   */
-  async initialize(): Promise<void> {
-    try {
-      // Check if tables already exist from previous implementation
-      const migrationStatus = await this.getMigrationStatus();
-
-      if (migrationStatus.isMigrated) {
-        console.error('[INFO] Database tables already exist, checking migration state');
-
-        // Check if __drizzle_migrations table exists
-        const drizzleMigrationResult = await this.client.execute(`
-          SELECT name FROM sqlite_master 
-          WHERE type='table' AND name='__drizzle_migrations'
-        `);
-
-        if (drizzleMigrationResult.rows.length === 0) {
-          // Tables exist but no Drizzle migration tracking
-          // Create the migration tracking table and mark as migrated
-          await this.client.execute(`
-            CREATE TABLE IF NOT EXISTS __drizzle_migrations (
-              id INTEGER PRIMARY KEY AUTOINCREMENT,
-              hash text NOT NULL UNIQUE,
-              created_at numeric NOT NULL DEFAULT (strftime('%s', 'now'))
-            )
-          `);
-
-          // Insert our migration as already applied
-          await this.client.execute(`
-            INSERT OR IGNORE INTO __drizzle_migrations (hash, created_at) 
-            VALUES ('0000_wooden_lady_bullseye', strftime('%s', 'now'))
-          `);
-
-          console.error('[INFO] Migration tracking initialized for existing tables');
-        }
-
-        return;
-      }
-
-      // Run migrations using Drizzle migrator
-      // Use package root to find migrations folder (works with npm install)
-      const packageRoot = findPackageRoot('drizzle migrations');
-      const migrationsPath = path.join(packageRoot, 'drizzle');
-
-      if (fs.existsSync(migrationsPath)) {
-        await migrate(this.db, { migrationsFolder: migrationsPath });
-        console.error('[INFO] Database migrations completed');
-      } else {
-        console.error('[WARN] No migrations folder found, using fallback table creation');
-        await this.createTablesFallback();
-      }
-    } catch (error) {
-      const errorMessage = `Migration failed: ${(error as Error).message}`;
-      console.error('[ERROR]', errorMessage);
-
-      // Try fallback as last resort
-      try {
-        await this.createTablesFallback();
-        console.error('[WARN] Fallback table creation completed');
-      } catch (fallbackError) {
-        throw new DatabaseError(
-          'Both migration and fallback failed',
-          'initialize',
-          fallbackError as Error,
-          { originalError: (error as Error).message }
-        );
-      }
-    }
-  }
-
-  /**
-   * Fallback table creation for development
-   * Only used if migrations fail
-   */
-  private async createTablesFallback(): Promise<void> {
-    // This is a minimal fallback - in production we should always use migrations
-    console.error('[INFO] Using fallback table creation');
-
-    // Create tables using the existing database connection
-    // The tables should already exist from previous runs
-    // This is just a safety net
-  }
-
-  /**
-   * 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 homeDir = path.join(os.homedir(), '.sylphx-flow');
-    const projectDir = path.join(process.cwd(), '.sylphx-flow');
-    const memoryDir = this.useHomeDir ? homeDir : projectDir;
-    return path.join(memoryDir, 'memory.db');
-  }
-
-  /**
-   * Get migration status
-   */
-  async getMigrationStatus(): Promise<{
-    isMigrated: boolean;
-    migrationCount: number;
-  }> {
-    try {
-      // Check if our main tables exist
-      const result = await this.client.execute(`
-        SELECT name FROM sqlite_master 
-        WHERE type='table' AND name IN ('memory', 'codebase_files', 'tfidf_terms')
-      `);
-
-      return {
-        isMigrated: result.rows.length >= 2, // At least memory and codebase_files
-        migrationCount: result.rows.length,
-      };
-    } catch (error) {
-      throw new DatabaseError(
-        'Failed to check migration status',
-        'getMigrationStatus',
-        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 critical tables exist
-      const migrationStatus = await this.getMigrationStatus();
-
-      // Test basic read/write operation
-      const testResult = await this.client.execute(`
-        SELECT count(*) as count FROM memory
-      `);
-
-      return {
-        healthy: true,
-        details: {
-          tablesExist: migrationStatus.isMigrated,
-          tableCount: migrationStatus.migrationCount,
-          memoryEntries: testResult.rows[0]?.count || 0,
-        },
-      };
-    } catch (error) {
-      return {
-        healthy: false,
-        error: (error as Error).message,
-      };
-    }
-  }
-}
-
-// Export schema and types
-export * from './schema.js';
-export { schema };
-
-// Re-export commonly used database functions (these will be added when memory-db is fully implemented)
-// export {
-//   storeMemory,
-//   retrieveMemory,
-//   searchMemory,
-//   clearMemory,
-// } from './memory-db';
-
-export { isDatabaseError } from '../utils/database-errors';

package/src/db/memory-db.ts

@@ -1,153 +0,0 @@
-/**
- * Memory 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 './memory-schema.js';
-
-export type MemoryDatabase = ReturnType<typeof drizzle<typeof schema>>;
-
-export class MemoryDatabaseClient extends BaseDatabaseClient<typeof schema> {
-  constructor() {
-    super('memory', schema);
-  }
-
-  /**
-   * Initialize memory 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;
-      }
-
-      // Run migrations
-      const _migrationsPath = path.join(process.cwd(), 'drizzle', 'memory');
-
-      // For now, create tables directly since we don't have migration files yet
-      await this.createTables();
-      console.error('[INFO] Memory database tables created');
-    } catch (error) {
-      throw new DatabaseError(
-        'Failed to initialize memory database',
-        'memory.initialize',
-        error as Error
-      );
-    }
-  }
-
-  /**
-   * Create tables directly (fallback)
-   */
-  private async createTables(): Promise<void> {
-    // Create memory table
-    await this.createTable(`
-        CREATE TABLE IF NOT EXISTS memory_table (
-          key TEXT NOT NULL,
-          namespace TEXT NOT NULL DEFAULT 'default',
-          value TEXT NOT NULL,
-          timestamp INTEGER NOT NULL,
-          created_at TEXT NOT NULL,
-          updated_at TEXT NOT NULL,
-          PRIMARY KEY (key, namespace)
-        )
-      `);
-
-    // Create indexes
-    await this.createIndex(`
-        CREATE INDEX IF NOT EXISTS idx_memory_namespace ON memory_table (namespace)
-      `);
-
-    await this.createIndex(`
-        CREATE INDEX IF NOT EXISTS idx_memory_timestamp ON memory_table (timestamp)
-      `);
-
-    await this.createIndex(`
-        CREATE INDEX IF NOT EXISTS idx_memory_key ON memory_table (key)
-      `);
-  }
-
-  /**
-   * Get migration status
-   */
-  async getMigrationStatus(): Promise<{
-    isMigrated: boolean;
-    migrationCount: number;
-  }> {
-    try {
-      const exists = await this.tableExists('memory_table');
-      return {
-        isMigrated: exists,
-        migrationCount: exists ? 1 : 0,
-      };
-    } catch (error) {
-      throw new DatabaseError(
-        'Failed to check memory database migration status',
-        'memory.getMigrationStatus',
-        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 memory table exists
-      const migrationStatus = await this.getMigrationStatus();
-
-      // Test basic read/write operation
-      const testResult = await this.client.execute(`
-        SELECT count(*) as count FROM memory_table
-      `);
-
-      return {
-        healthy: true,
-        details: {
-          tablesExist: migrationStatus.isMigrated,
-          memoryEntries: 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 memoryDir = path.join(process.cwd(), '.sylphx-flow');
-    return path.join(memoryDir, 'memory.db');
-  }
-}
-
-// Export schema and types
-export * from './memory-schema.js';
-export { schema };

package/src/db/memory-schema.ts

@@ -1,29 +0,0 @@
-/**
- * Memory database schema - 永久記憶數據 (應該上 Git)
- * 包含用戶記憶、協調數據等需要持久化的信息
- */
-
-import { index, integer, primaryKey, sqliteTable, text } from 'drizzle-orm/sqlite-core';
-
-// Memory table for persistent storage (永久記憶)
-export const memory = sqliteTable(
-  'memory_table',
-  {
-    key: text('key').notNull(),
-    namespace: text('namespace').notNull().default('default'),
-    value: text('value').notNull(),
-    timestamp: integer('timestamp').notNull(),
-    created_at: text('created_at').notNull(),
-    updated_at: text('updated_at').notNull(),
-  },
-  (table) => [
-    primaryKey({ columns: [table.key, table.namespace] }),
-    index('idx_memory_namespace').on(table.namespace),
-    index('idx_memory_timestamp').on(table.timestamp),
-    index('idx_memory_key').on(table.key),
-  ]
-);
-
-// Types for memory database
-export type Memory = typeof memory.$inferSelect;
-export type NewMemory = typeof memory.$inferInsert;