kiro-memory 1.8.1 → 2.1.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;
+  /**
+   * Readonly accessor for the underlying Database instance.
+   * Prefer using query() and run() proxy methods directly.
+   */
+  get db() {
+    return this._db;
+  }
   /**
-   * @param dbPath - Percorso al file SQLite (default: DB_PATH)
-   * @param skipMigrations - Se true, salta il migration runner (per hook ad alta frequenza)
+   * @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 {
@@ -712,21 +628,7 @@ var MigrationRunner = class {
     ];
   }
 };
-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
 };

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

@@ -72,9 +72,25 @@ function consolidateObservations(db, project, options = {}) {
     ORDER BY cnt DESC
   `).all(project, minGroupSize);
   if (groups.length === 0) return { merged: 0, removed: 0 };
-  let totalMerged = 0;
-  let totalRemoved = 0;
+  if (options.dryRun) {
+    let totalMerged = 0;
+    let totalRemoved = 0;
+    for (const group of groups) {
+      const obsIds = group.ids.split(",").map(Number);
+      const placeholders = obsIds.map(() => "?").join(",");
+      const count = db.query(
+        `SELECT COUNT(*) as cnt FROM observations WHERE id IN (${placeholders})`
+      ).get(...obsIds)?.cnt || 0;
+      if (count >= minGroupSize) {
+        totalMerged += 1;
+        totalRemoved += count - 1;
+      }
+    }
+    return { merged: totalMerged, removed: totalRemoved };
+  }
   const runConsolidation = db.transaction(() => {
+    let merged = 0;
+    let removed = 0;
     for (const group of groups) {
       const obsIds = group.ids.split(",").map(Number);
       const placeholders = obsIds.map(() => "?").join(",");
@@ -82,11 +98,6 @@ function consolidateObservations(db, project, options = {}) {
         `SELECT * FROM observations WHERE id IN (${placeholders}) ORDER BY created_at_epoch DESC`
       ).all(...obsIds);
       if (observations.length < minGroupSize) continue;
-      if (options.dryRun) {
-        totalMerged += 1;
-        totalRemoved += observations.length - 1;
-        continue;
-      }
       const keeper = observations[0];
       const others = observations.slice(1);
       const uniqueTexts = /* @__PURE__ */ new Set();
@@ -99,18 +110,18 @@ function consolidateObservations(db, project, options = {}) {
       const consolidatedText = Array.from(uniqueTexts).join("\n---\n").substring(0, 1e5);
       db.run(
         "UPDATE observations SET text = ?, title = ? WHERE id = ?",
-        [consolidatedText, `[consolidato x${observations.length}] ${keeper.title}`, keeper.id]
+        [consolidatedText, `[consolidated x${observations.length}] ${keeper.title}`, keeper.id]
       );
       const removeIds = others.map((o) => o.id);
       const removePlaceholders = removeIds.map(() => "?").join(",");
       db.run(`DELETE FROM observations WHERE id IN (${removePlaceholders})`, removeIds);
       db.run(`DELETE FROM observation_embeddings WHERE observation_id IN (${removePlaceholders})`, removeIds);
-      totalMerged += 1;
-      totalRemoved += removeIds.length;
+      merged += 1;
+      removed += removeIds.length;
     }
+    return { merged, removed };
   });
-  runConsolidation();
-  return { merged: totalMerged, removed: totalRemoved };
+  return runConsolidation();
 }
 export {
   consolidateObservations,

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

@@ -8,7 +8,7 @@ function escapeLikePattern(input) {
 }
 function sanitizeFTS5Query(query) {
   const trimmed = query.length > 1e4 ? query.substring(0, 1e4) : query;
-  const terms = trimmed.replace(/[""]/g, "").split(/\s+/).filter((t) => t.length > 0).slice(0, 100).map((t) => `"${t}"`);
+  const terms = trimmed.replace(/[""\u0022]/g, "").split(/\s+/).filter((t) => t.length > 0).slice(0, 100).map((t) => `"${t}"`);
   return terms.join(" ");
 }
 function searchObservationsFTS(db, query, filters = {}) {
@@ -173,26 +173,38 @@ function getTimeline(db, anchorId, depthBefore = 5, depthAfter = 5) {
   return [...before, ...self, ...after];
 }
 function getProjectStats(db, project) {
-  const obsStmt = db.query("SELECT COUNT(*) as count FROM observations WHERE project = ?");
-  const sumStmt = db.query("SELECT COUNT(*) as count FROM summaries WHERE project = ?");
-  const sesStmt = db.query("SELECT COUNT(*) as count FROM sessions WHERE project = ?");
-  const prmStmt = db.query("SELECT COUNT(*) as count FROM prompts WHERE project = ?");
-  const discoveryStmt = db.query(
-    "SELECT COALESCE(SUM(discovery_tokens), 0) as total FROM observations WHERE project = ?"
-  );
-  const discoveryTokens = discoveryStmt.get(project)?.total || 0;
-  const readStmt = db.query(
-    `SELECT COALESCE(SUM(
-      CAST((LENGTH(COALESCE(title, '')) + LENGTH(COALESCE(narrative, ''))) / 4 AS INTEGER)
-    ), 0) as total FROM observations WHERE project = ?`
-  );
-  const readTokens = readStmt.get(project)?.total || 0;
+  const sql = `
+    WITH
+      obs_stats AS (
+        SELECT
+          COUNT(*) as count,
+          COALESCE(SUM(discovery_tokens), 0) as discovery_tokens,
+          COALESCE(SUM(
+            CAST((LENGTH(COALESCE(title, '')) + LENGTH(COALESCE(narrative, ''))) / 4 AS INTEGER)
+          ), 0) as read_tokens
+        FROM observations WHERE project = ?
+      ),
+      sum_count AS (SELECT COUNT(*) as count FROM summaries WHERE project = ?),
+      ses_count AS (SELECT COUNT(*) as count FROM sessions WHERE project = ?),
+      prm_count AS (SELECT COUNT(*) as count FROM prompts WHERE project = ?)
+    SELECT
+      obs_stats.count as observations,
+      obs_stats.discovery_tokens,
+      obs_stats.read_tokens,
+      sum_count.count as summaries,
+      ses_count.count as sessions,
+      prm_count.count as prompts
+    FROM obs_stats, sum_count, ses_count, prm_count
+  `;
+  const row = db.query(sql).get(project, project, project, project);
+  const discoveryTokens = row?.discovery_tokens || 0;
+  const readTokens = row?.read_tokens || 0;
   const savings = Math.max(0, discoveryTokens - readTokens);
   return {
-    observations: obsStmt.get(project)?.count || 0,
-    summaries: sumStmt.get(project)?.count || 0,
-    sessions: sesStmt.get(project)?.count || 0,
-    prompts: prmStmt.get(project)?.count || 0,
+    observations: row?.observations || 0,
+    summaries: row?.summaries || 0,
+    sessions: row?.sessions || 0,
+    prompts: row?.prompts || 0,
     tokenEconomics: { discoveryTokens, readTokens, savings }
   };
 }

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

@@ -46,6 +46,10 @@ function getActiveSessions(db) {
   const query = db.query("SELECT * FROM sessions WHERE status = 'active' ORDER BY started_at_epoch DESC");
   return query.all();
 }
+function getAllSessions(db, limit = 100) {
+  const query = db.query("SELECT * FROM sessions ORDER BY started_at_epoch DESC LIMIT ?");
+  return query.all(limit);
+}
 function getSessionsByProject(db, project, limit = 100) {
   const query = db.query("SELECT * FROM sessions WHERE project = ? ORDER BY started_at_epoch DESC LIMIT ?");
   return query.all(project, limit);
@@ -55,6 +59,7 @@ export {
   createSession,
   failSession,
   getActiveSessions,
+  getAllSessions,
   getSessionByContentId,
   getSessionById,
   getSessionsByProject,