kiro-memory 1.9.0 → 3.0.0

package/plugin/dist/services/sqlite/Database.js

@@ -4,14 +4,15 @@ import { createRequire } from 'module';const require = createRequire(import.meta
 import BetterSqlite3 from "better-sqlite3";
 var Database = class {
   _db;
+  _stmtCache = /* @__PURE__ */ new Map();
   constructor(path, options) {
     this._db = new BetterSqlite3(path, {
-      // better-sqlite3 crea il file di default (non serve 'create')
+      // better-sqlite3 creates the file by default ('create' not needed)
       readonly: options?.readwrite === false ? true : false
     });
   }
   /**
-   * Esegui una query SQL senza risultati
+   * Execute a SQL query without results
    */
   run(sql, params) {
     const stmt = this._db.prepare(sql);
@@ -19,51 +20,53 @@ var Database = class {
     return result;
   }
   /**
-   * Prepara una query con interfaccia compatibile bun:sqlite
+   * Prepare a query with bun:sqlite-compatible interface.
+   * Returns a cached prepared statement for repeated queries.
    */
   query(sql) {
-    return new BunQueryCompat(this._db, sql);
+    let cached = this._stmtCache.get(sql);
+    if (!cached) {
+      cached = new BunQueryCompat(this._db, sql);
+      this._stmtCache.set(sql, cached);
+    }
+    return cached;
   }
   /**
-   * Crea una transazione
+   * Create a transaction
    */
   transaction(fn) {
     return this._db.transaction(fn);
   }
   /**
-   * Chiudi la connessione
+   * Close the connection
    */
   close() {
+    this._stmtCache.clear();
     this._db.close();
   }
 };
 var BunQueryCompat = class {
-  _db;
-  _sql;
+  _stmt;
   constructor(db, sql) {
-    this._db = db;
-    this._sql = sql;
+    this._stmt = db.prepare(sql);
   }
   /**
-   * Restituisce tutte le righe
+   * Returns all rows
    */
   all(...params) {
-    const stmt = this._db.prepare(this._sql);
-    return params.length > 0 ? stmt.all(...params) : stmt.all();
+    return params.length > 0 ? this._stmt.all(...params) : this._stmt.all();
   }
   /**
-   * Restituisce la prima riga o null
+   * Returns the first row or null
    */
   get(...params) {
-    const stmt = this._db.prepare(this._sql);
-    return params.length > 0 ? stmt.get(...params) : stmt.get();
+    return params.length > 0 ? this._stmt.get(...params) : this._stmt.get();
   }
   /**
-   * Esegui senza risultati
+   * Execute without results
    */
   run(...params) {
-    const stmt = this._db.prepare(this._sql);
-    return params.length > 0 ? stmt.run(...params) : stmt.run();
+    return params.length > 0 ? this._stmt.run(...params) : this._stmt.run();
   }
 };
 
@@ -324,150 +327,63 @@ function ensureDir(dirPath) {
 // src/services/sqlite/Database.ts
 var SQLITE_MMAP_SIZE_BYTES = 256 * 1024 * 1024;
 var SQLITE_CACHE_SIZE_PAGES = 1e4;
-var dbInstance = null;
 var KiroMemoryDatabase = class {
-  db;
+  _db;
   /**
-   * @param dbPath - Percorso al file SQLite (default: DB_PATH)
-   * @param skipMigrations - Se true, salta il migration runner (per hook ad alta frequenza)
+   * Readonly accessor for the underlying Database instance.
+   * Prefer using query() and run() proxy methods directly.
+   */
+  get db() {
+    return this._db;
+  }
+  /**
+   * @param dbPath - Path to the SQLite file (default: DB_PATH)
+   * @param skipMigrations - If true, skip the migration runner (for high-frequency hooks)
    */
   constructor(dbPath = DB_PATH, skipMigrations = false) {
     if (dbPath !== ":memory:") {
       ensureDir(DATA_DIR);
     }
-    this.db = new Database(dbPath, { create: true, readwrite: true });
-    this.db.run("PRAGMA journal_mode = WAL");
-    this.db.run("PRAGMA synchronous = NORMAL");
-    this.db.run("PRAGMA foreign_keys = ON");
-    this.db.run("PRAGMA temp_store = memory");
-    this.db.run(`PRAGMA mmap_size = ${SQLITE_MMAP_SIZE_BYTES}`);
-    this.db.run(`PRAGMA cache_size = ${SQLITE_CACHE_SIZE_PAGES}`);
+    this._db = new Database(dbPath, { create: true, readwrite: true });
+    this._db.run("PRAGMA journal_mode = WAL");
+    this._db.run("PRAGMA busy_timeout = 5000");
+    this._db.run("PRAGMA synchronous = NORMAL");
+    this._db.run("PRAGMA foreign_keys = ON");
+    this._db.run("PRAGMA temp_store = memory");
+    this._db.run(`PRAGMA mmap_size = ${SQLITE_MMAP_SIZE_BYTES}`);
+    this._db.run(`PRAGMA cache_size = ${SQLITE_CACHE_SIZE_PAGES}`);
     if (!skipMigrations) {
-      const migrationRunner = new MigrationRunner(this.db);
+      const migrationRunner = new MigrationRunner(this._db);
       migrationRunner.runAllMigrations();
     }
   }
   /**
-   * Esegue una funzione all'interno di una transazione atomica.
-   * Se fn() lancia un errore, la transazione viene annullata automaticamente.
-   */
-  withTransaction(fn) {
-    const transaction = this.db.transaction(fn);
-    return transaction(this.db);
-  }
-  /**
-   * Close the database connection
-   */
-  close() {
-    this.db.close();
-  }
-};
-var DatabaseManager = class _DatabaseManager {
-  static instance;
-  db = null;
-  migrations = [];
-  static getInstance() {
-    if (!_DatabaseManager.instance) {
-      _DatabaseManager.instance = new _DatabaseManager();
-    }
-    return _DatabaseManager.instance;
-  }
-  /**
-   * Register a migration to be run during initialization
-   */
-  registerMigration(migration) {
-    this.migrations.push(migration);
-    this.migrations.sort((a, b) => a.version - b.version);
-  }
-  /**
-   * Initialize database connection with optimized settings
+   * Prepare a query (delegates to underlying Database).
+   * Proxy method to avoid ctx.db.db.query() double access.
    */
-  async initialize() {
-    if (this.db) {
-      return this.db;
-    }
-    ensureDir(DATA_DIR);
-    this.db = new Database(DB_PATH, { create: true, readwrite: true });
-    this.db.run("PRAGMA journal_mode = WAL");
-    this.db.run("PRAGMA synchronous = NORMAL");
-    this.db.run("PRAGMA foreign_keys = ON");
-    this.db.run("PRAGMA temp_store = memory");
-    this.db.run(`PRAGMA mmap_size = ${SQLITE_MMAP_SIZE_BYTES}`);
-    this.db.run(`PRAGMA cache_size = ${SQLITE_CACHE_SIZE_PAGES}`);
-    this.initializeSchemaVersions();
-    await this.runMigrations();
-    dbInstance = this.db;
-    return this.db;
+  query(sql) {
+    return this._db.query(sql);
   }
   /**
-   * Get the current database connection
+   * Execute a SQL statement without results (delegates to underlying Database).
+   * Proxy method to avoid ctx.db.db.run() double access.
    */
-  getConnection() {
-    if (!this.db) {
-      throw new Error("Database not initialized. Call initialize() first.");
-    }
-    return this.db;
+  run(sql, params) {
+    return this._db.run(sql, params);
   }
   /**
-   * Execute a function within a transaction
+   * Executes a function within an atomic transaction.
+   * If fn() throws an error, the transaction is automatically rolled back.
    */
   withTransaction(fn) {
-    const db = this.getConnection();
-    const transaction = db.transaction(fn);
-    return transaction(db);
+    const transaction = this._db.transaction(fn);
+    return transaction(this._db);
   }
   /**
    * Close the database connection
    */
   close() {
-    if (this.db) {
-      this.db.close();
-      this.db = null;
-      dbInstance = null;
-    }
-  }
-  /**
-   * Initialize the schema_versions table
-   */
-  initializeSchemaVersions() {
-    if (!this.db) return;
-    this.db.run(`
-      CREATE TABLE IF NOT EXISTS schema_versions (
-        id INTEGER PRIMARY KEY,
-        version INTEGER UNIQUE NOT NULL,
-        applied_at TEXT NOT NULL
-      )
-    `);
-  }
-  /**
-   * Run all pending migrations
-   */
-  async runMigrations() {
-    if (!this.db) return;
-    const query = this.db.query("SELECT version FROM schema_versions ORDER BY version");
-    const appliedVersions = query.all().map((row) => row.version);
-    const maxApplied = appliedVersions.length > 0 ? Math.max(...appliedVersions) : 0;
-    for (const migration of this.migrations) {
-      if (migration.version > maxApplied) {
-        logger.info("DB", `Applying migration ${migration.version}`);
-        const transaction = this.db.transaction(() => {
-          migration.up(this.db);
-          const insertQuery = this.db.query("INSERT INTO schema_versions (version, applied_at) VALUES (?, ?)");
-          insertQuery.run(migration.version, (/* @__PURE__ */ new Date()).toISOString());
-        });
-        transaction();
-        logger.info("DB", `Migration ${migration.version} applied successfully`);
-      }
-    }
-  }
-  /**
-   * Get current schema version
-   */
-  getCurrentVersion() {
-    if (!this.db) return 0;
-    const query = this.db.query("SELECT MAX(version) as version FROM schema_versions");
-    const result = query.get();
-    return result?.version || 0;
+    this._db.close();
   }
 };
 var MigrationRunner = class {
@@ -708,25 +624,82 @@ var MigrationRunner = class {
           db.run("CREATE INDEX IF NOT EXISTS idx_summaries_project_epoch ON summaries(project, created_at_epoch DESC)");
           db.run("CREATE INDEX IF NOT EXISTS idx_prompts_project_epoch ON prompts(project, created_at_epoch DESC)");
         }
+      },
+      {
+        version: 10,
+        up: (db) => {
+          db.run(`
+            CREATE TABLE IF NOT EXISTS job_queue (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              type TEXT NOT NULL,
+              status TEXT NOT NULL DEFAULT 'pending',
+              payload TEXT,
+              result TEXT,
+              error TEXT,
+              retry_count INTEGER DEFAULT 0,
+              max_retries INTEGER DEFAULT 3,
+              priority INTEGER DEFAULT 0,
+              created_at TEXT NOT NULL,
+              created_at_epoch INTEGER NOT NULL,
+              started_at_epoch INTEGER,
+              completed_at_epoch INTEGER
+            )
+          `);
+          db.run("CREATE INDEX IF NOT EXISTS idx_jobs_status ON job_queue(status)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_jobs_type ON job_queue(type)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_jobs_priority ON job_queue(status, priority DESC, created_at_epoch ASC)");
+        }
+      },
+      {
+        version: 11,
+        up: (db) => {
+          db.run("ALTER TABLE observations ADD COLUMN auto_category TEXT");
+          db.run("CREATE INDEX IF NOT EXISTS idx_observations_category ON observations(auto_category)");
+        }
+      },
+      {
+        version: 12,
+        up: (db) => {
+          db.run(`
+            CREATE TABLE IF NOT EXISTS github_links (
+              id INTEGER PRIMARY KEY AUTOINCREMENT,
+              observation_id INTEGER,
+              session_id TEXT,
+              repo TEXT NOT NULL,
+              issue_number INTEGER,
+              pr_number INTEGER,
+              event_type TEXT NOT NULL,
+              action TEXT,
+              title TEXT,
+              url TEXT,
+              author TEXT,
+              created_at TEXT NOT NULL,
+              created_at_epoch INTEGER NOT NULL,
+              FOREIGN KEY (observation_id) REFERENCES observations(id)
+            )
+          `);
+          db.run("CREATE INDEX IF NOT EXISTS idx_github_links_repo ON github_links(repo)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_github_links_obs ON github_links(observation_id)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_github_links_event ON github_links(event_type)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_github_links_repo_issue ON github_links(repo, issue_number)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_github_links_repo_pr ON github_links(repo, pr_number)");
+        }
+      },
+      {
+        version: 13,
+        up: (db) => {
+          db.run("CREATE INDEX IF NOT EXISTS idx_observations_keyset ON observations(created_at_epoch DESC, id DESC)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_observations_project_keyset ON observations(project, created_at_epoch DESC, id DESC)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_summaries_keyset ON summaries(created_at_epoch DESC, id DESC)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_summaries_project_keyset ON summaries(project, created_at_epoch DESC, id DESC)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_prompts_keyset ON prompts(created_at_epoch DESC, id DESC)");
+          db.run("CREATE INDEX IF NOT EXISTS idx_prompts_project_keyset ON prompts(project, created_at_epoch DESC, id DESC)");
+        }
       }
     ];
   }
 };
-function getDatabase() {
-  if (!dbInstance) {
-    throw new Error("Database not initialized. Call DatabaseManager.getInstance().initialize() first.");
-  }
-  return dbInstance;
-}
-async function initializeDatabase() {
-  const manager = DatabaseManager.getInstance();
-  return await manager.initialize();
-}
 export {
-  KiroMemoryDatabase as ContextKitDatabase,
   Database,
-  DatabaseManager,
-  KiroMemoryDatabase,
-  getDatabase,
-  initializeDatabase
+  KiroMemoryDatabase
 };