squish-memory 1.0.2 → 1.2.0

package/dist/core/utils/summarization-helpers.d.ts

@@ -10,10 +10,6 @@ export declare function chunkMessages(messages: any[], chunkSize: number): any[]
  * Get rolling window of messages
  */
 export declare function getRollingWindow(messages: any[], windowSize: number): any[];
-/**
- * Estimate tokens in text (rough approximation)
- */
-export declare function estimateTokens(text: string): number;
 /**
  * Calculate tokens saved by summarization
  */

package/dist/core/utils/summarization-helpers.js

@@ -2,6 +2,7 @@
  * Shared Summarization Strategy Utilities
  * Common patterns for different summarization approaches
  */
+import { estimateTokens } from '../context/context-window.js';
 /**
  * Chunk messages for incremental summarization
  */
@@ -21,12 +22,6 @@ export function getRollingWindow(messages, windowSize) {
     }
     return messages.slice(-windowSize);
 }
-/**
- * Estimate tokens in text (rough approximation)
- */
-export function estimateTokens(text) {
-    return Math.round(text.length / 4);
-}
 /**
  * Calculate tokens saved by summarization
  */

package/dist/core/utils/vector-operations.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Vector Operations Utilities
+ *
+ * Provides mathematical operations for vector computations, primarily focused on
+ * cosine similarity calculations for embedding comparisons.
+ *
+ * All functions handle edge cases gracefully and are optimized for performance.
+ */
+/**
+ * Calculates the cosine similarity between two vectors.
+ *
+ * Cosine similarity measures the cosine of the angle between two vectors,
+ * providing a normalized measure of similarity that ranges from -1 (opposite)
+ * to 1 (identical), with 0 indicating orthogonality (no similarity).
+ *
+ * The implementation uses the standard formula:
+ *   cos(θ) = (A · B) / (||A|| * ||B||)
+ *
+ * Edge case handling:
+ * - Returns 0 if either vector is null/undefined
+ * - Returns 0 if vectors have different lengths
+ * - Returns 0 if either vector has zero magnitude (norm = 0)
+ *
+ * @param a - First vector as array of numbers
+ * @param b - Second vector as array of numbers
+ * @returns Cosine similarity value in range [-1, 1], or 0 for invalid inputs
+ *
+ * @example
+ * ```typescript
+ * const vec1 = [1, 2, 3];
+ * const vec2 = [4, 5, 6];
+ * const similarity = cosineSimilarity(vec1, vec2); // ~0.974
+ * ```
+ *
+ * @performance
+ * - Time complexity: O(n) where n is vector length
+ * - Space complexity: O(1) - uses only accumulator variables
+ * - Optimized with single-pass computation of dot product and norms
+ */
+export declare function cosineSimilarity(a: number[] | null | undefined, b: number[] | null | undefined): number;
+/**
+ * Calculates the Euclidean distance between two vectors.
+ *
+ * @param a - First vector
+ * @param b - Second vector
+ * @returns Euclidean distance, or Infinity if vectors have different lengths
+ */
+export declare function euclideanDistance(a: number[] | null | undefined, b: number[] | null | undefined): number;
+/**
+ * Normalizes a vector to unit length (magnitude = 1).
+ *
+ * @param vec - Input vector
+ * @returns Normalized vector, or null if input is null or zero vector
+ */
+export declare function normalizeVector(vec: number[] | null | undefined): number[] | null;
+/**
+ * Computes the dot product of two vectors.
+ *
+ * @param a - First vector
+ * @param b - Second vector
+ * @returns Dot product, or 0 if vectors are invalid or different lengths
+ */
+export declare function dotProduct(a: number[] | null | undefined, b: number[] | null | undefined): number;
+/**
+ * Calculates the magnitude (L2 norm) of a vector.
+ *
+ * @param vec - Input vector
+ * @returns Magnitude of the vector, or 0 if input is null
+ */
+export declare function magnitude(vec: number[] | null | undefined): number;
+//# sourceMappingURL=vector-operations.d.ts.map

package/dist/core/utils/vector-operations.js

@@ -0,0 +1,129 @@
+/**
+ * Vector Operations Utilities
+ *
+ * Provides mathematical operations for vector computations, primarily focused on
+ * cosine similarity calculations for embedding comparisons.
+ *
+ * All functions handle edge cases gracefully and are optimized for performance.
+ */
+/**
+ * Calculates the cosine similarity between two vectors.
+ *
+ * Cosine similarity measures the cosine of the angle between two vectors,
+ * providing a normalized measure of similarity that ranges from -1 (opposite)
+ * to 1 (identical), with 0 indicating orthogonality (no similarity).
+ *
+ * The implementation uses the standard formula:
+ *   cos(θ) = (A · B) / (||A|| * ||B||)
+ *
+ * Edge case handling:
+ * - Returns 0 if either vector is null/undefined
+ * - Returns 0 if vectors have different lengths
+ * - Returns 0 if either vector has zero magnitude (norm = 0)
+ *
+ * @param a - First vector as array of numbers
+ * @param b - Second vector as array of numbers
+ * @returns Cosine similarity value in range [-1, 1], or 0 for invalid inputs
+ *
+ * @example
+ * ```typescript
+ * const vec1 = [1, 2, 3];
+ * const vec2 = [4, 5, 6];
+ * const similarity = cosineSimilarity(vec1, vec2); // ~0.974
+ * ```
+ *
+ * @performance
+ * - Time complexity: O(n) where n is vector length
+ * - Space complexity: O(1) - uses only accumulator variables
+ * - Optimized with single-pass computation of dot product and norms
+ */
+export function cosineSimilarity(a, b) {
+    // Guard against null/undefined inputs
+    if (!a || !b)
+        return 0;
+    // Vectors must have same dimensions
+    if (a.length !== b.length)
+        return 0;
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    // Single pass to compute dot product and norms
+    for (let i = 0; i < a.length; i++) {
+        dotProduct += a[i] * b[i];
+        normA += a[i] * a[i];
+        normB += b[i] * b[i];
+    }
+    // Handle zero vectors (avoid division by zero)
+    if (normA === 0 || normB === 0)
+        return 0;
+    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+/**
+ * Calculates the Euclidean distance between two vectors.
+ *
+ * @param a - First vector
+ * @param b - Second vector
+ * @returns Euclidean distance, or Infinity if vectors have different lengths
+ */
+export function euclideanDistance(a, b) {
+    if (!a || !b)
+        return Infinity;
+    if (a.length !== b.length)
+        return Infinity;
+    let sum = 0;
+    for (let i = 0; i < a.length; i++) {
+        const diff = a[i] - b[i];
+        sum += diff * diff;
+    }
+    return Math.sqrt(sum);
+}
+/**
+ * Normalizes a vector to unit length (magnitude = 1).
+ *
+ * @param vec - Input vector
+ * @returns Normalized vector, or null if input is null or zero vector
+ */
+export function normalizeVector(vec) {
+    if (!vec)
+        return null;
+    let norm = 0;
+    for (let i = 0; i < vec.length; i++) {
+        norm += vec[i] * vec[i];
+    }
+    if (norm === 0)
+        return null;
+    const magnitude = Math.sqrt(norm);
+    return vec.map(val => val / magnitude);
+}
+/**
+ * Computes the dot product of two vectors.
+ *
+ * @param a - First vector
+ * @param b - Second vector
+ * @returns Dot product, or 0 if vectors are invalid or different lengths
+ */
+export function dotProduct(a, b) {
+    if (!a || !b || a.length !== b.length)
+        return 0;
+    let result = 0;
+    for (let i = 0; i < a.length; i++) {
+        result += a[i] * b[i];
+    }
+    return result;
+}
+/**
+ * Calculates the magnitude (L2 norm) of a vector.
+ *
+ * @param vec - Input vector
+ * @returns Magnitude of the vector, or 0 if input is null
+ */
+export function magnitude(vec) {
+    if (!vec)
+        return 0;
+    let sum = 0;
+    for (let i = 0; i < vec.length; i++) {
+        sum += vec[i] * vec[i];
+    }
+    return Math.sqrt(sum);
+}
+//# sourceMappingURL=vector-operations.js.map

package/dist/db/adapter.d.ts

@@ -1,7 +1,7 @@
-export declare function createDb(): Promise<(import("drizzle-orm/node-postgres").NodePgDatabase<typeof import("../drizzle/schema.js")> & {
+export declare function createDb(): Promise<(import("drizzle-orm/node-postgres").NodePgDatabase<typeof import("./drizzle/schema.js")> & {
     $client: import("pg").Pool;
-}) | (import("drizzle-orm/better-sqlite3").BetterSQLite3Database<typeof import("../drizzle/schema-sqlite.js")> & {
+}) | (import("drizzle-orm/better-sqlite3").BetterSQLite3Database<typeof import("./drizzle/schema-sqlite.js")> & {
     $client: import("better-sqlite3").Database;
-}) | import("drizzle-orm/sql-js").SQLJsDatabase<typeof import("../drizzle/schema-sqlite.js")>>;
+}) | import("drizzle-orm/sql-js").SQLJsDatabase<typeof import("./drizzle/schema-sqlite.js")>>;
 export default createDb;
 //# sourceMappingURL=adapter.d.ts.map

package/dist/db/adapter.js

@@ -1,10 +1,54 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { config, getDataDir } from '../config.js';
 import { ensurePostgresSchema, ensureSqliteSchema } from './bootstrap.js';
 import { logger } from '../core/logger.js';
+const SQL_JS_WASM_RELATIVE_PATH = '../vendor/sql.js/sql-wasm.wasm';
+function isBunRuntime() {
+    return typeof globalThis.Bun !== 'undefined';
+}
+function formatInitializationError(label, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return `${label}: ${message}`;
+}
+function shouldPersistSql(query) {
+    return /^\s*(insert|update|delete|create|alter|drop|replace|pragma|begin|commit|rollback|vacuum|reindex)\b/i.test(query);
+}
+function persistSqlJsDatabase(sqlite, dbPath) {
+    fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+    fs.writeFileSync(dbPath, Buffer.from(sqlite.export()));
+}
+function resolveSqlJsWasmPath() {
+    const currentDir = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        path.resolve(currentDir, SQL_JS_WASM_RELATIVE_PATH),
+        path.resolve(currentDir, '../../node_modules/sql.js/dist/sql-wasm.wasm'),
+        path.resolve(process.cwd(), 'node_modules/sql.js/dist/sql-wasm.wasm'),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error(`sql.js wasm asset not found. Looked in: ${candidates.join(', ')}`);
+}
+function wrapSqlJsStatement(stmt, sqlite, dbPath, query) {
+    const persistAfterRun = shouldPersistSql(query);
+    if (persistAfterRun && typeof stmt.run === 'function') {
+        const originalRun = stmt.run.bind(stmt);
+        stmt.run = (...args) => {
+            const result = originalRun(...args);
+            persistSqlJsDatabase(sqlite, dbPath);
+            return result;
+        };
+    }
+    return stmt;
+}
 async function createBunSqliteDb(dbPath) {
     // @ts-ignore - bun:sqlite module not found in types but works at runtime
     const { drizzle } = await import('drizzle-orm/bun-sqlite');
-    const schemaModule = await import('../drizzle/schema-sqlite.js');
+    const schemaModule = await import('./drizzle/schema-sqlite.js');
     // Bun SQLite doesn't need file path for in-memory, but we'll use file path for persistence
     // @ts-ignore - bun:sqlite module not found in types but works at runtime
     const sqlite = new (await import('bun:sqlite')).default(dbPath);
@@ -25,7 +69,7 @@ export async function createDb() {
 async function createPostgresDb() {
     const { Pool } = await import('pg');
     const { drizzle } = await import('drizzle-orm/node-postgres');
-    const schemaModule = await import('../drizzle/schema.js');
+    const schemaModule = await import('./drizzle/schema.js');
     const pool = new Pool({
         connectionString: process.env.DATABASE_URL,
         max: 20,
@@ -35,49 +79,46 @@ async function createPostgresDb() {
 }
 async function createSqliteDb() {
     const dbPath = `${getDataDir()}/squish.db`;
-    // Try bun:sqlite first (Bun's built-in SQLite)
-    try {
-        return await createBunSqliteDb(dbPath);
-    }
-    catch (bunSqliteError) {
-        logger.warn('bun:sqlite failed, trying better-sqlite3', {
-            error: bunSqliteError.message
-        });
-        // Try better-sqlite3 second (best performance)
+    const errors = [];
+    if (isBunRuntime()) {
         try {
-            return await createBetterSqliteDb(dbPath);
+            return await createBunSqliteDb(dbPath);
         }
-        catch (betterSqliteError) {
-            logger.warn('better-sqlite3 failed, trying sql.js fallback', {
-                error: betterSqliteError.message
-            });
-            // Fallback to sql.js (pure JavaScript, no native module)
-            try {
-                return await createSqlJsDb(dbPath);
-            }
-            catch (sqlJsError) {
-                // All failed - this is critical, Squish cannot work without DB
-                logger.error('CRITICAL: SQLite database initialization failed', {
-                    bunSqliteError: bunSqliteError.message,
-                    betterSqliteError: betterSqliteError.message,
-                    sqlJsError: sqlJsError.message
+        catch (error) {
+            errors.push(formatInitializationError('bun:sqlite', error));
+            if (process.env.DEBUG === 'true') {
+                logger.warn('bun:sqlite failed, trying Node-compatible drivers', {
+                    error: error instanceof Error ? error.message : String(error),
                 });
-                throw new Error(`Squish requires SQLite to function. Database initialization failed.\n` +
-                    `Primary error (bun:sqlite): ${bunSqliteError.message}\n` +
-                    `Secondary error (better-sqlite3): ${betterSqliteError.message}\n` +
-                    `Fallback error (sql.js): ${sqlJsError.message}\n\n` +
-                    `Solutions:\n` +
-                    `1. Install build tools: npm install -g windows-build-tools (Windows)\n` +
-                    `2. Or use PostgreSQL instead by setting DATABASE_URL environment variable`);
             }
         }
     }
+    try {
+        return await createBetterSqliteDb(dbPath);
+    }
+    catch (error) {
+        errors.push(formatInitializationError('better-sqlite3', error));
+        if (process.env.DEBUG === 'true') {
+            logger.warn('better-sqlite3 failed, trying sql.js fallback', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    try {
+        return await createSqlJsDb(dbPath);
+    }
+    catch (error) {
+        errors.push(formatInitializationError('sql.js', error));
+    }
+    logger.error('CRITICAL: SQLite database initialization failed', { errors });
+    throw new Error('Squish requires a working local SQLite driver. Initialization failed.\n' +
+        errors.map((entry, index) => `${index + 1}. ${entry}`).join('\n'));
 }
 async function createBetterSqliteDb(dbPath) {
     const DatabaseModule = await import('better-sqlite3');
     const Database = DatabaseModule.default;
     const { drizzle } = await import('drizzle-orm/better-sqlite3');
-    const schemaModule = await import('../drizzle/schema-sqlite.js');
+    const schemaModule = await import('./drizzle/schema-sqlite.js');
     const sqlite = new Database(dbPath);
     // Enable foreign keys
     sqlite.pragma('foreign_keys = ON');
@@ -89,73 +130,43 @@ async function createSqlJsDb(dbPath) {
     // @ts-ignore - sql.js has no types but works fine
     const initSqlJs = await import('sql.js');
     const { drizzle } = await import('drizzle-orm/sql-js');
-    const schemaModule = await import('../drizzle/schema-sqlite.js');
-    const fs = await import('fs');
-    const path = await import('path');
-    const SQL = await initSqlJs.default();
+    const schemaModule = await import('./drizzle/schema-sqlite.js');
+    const wasmPath = resolveSqlJsWasmPath();
+    const SQL = await initSqlJs.default({
+        locateFile: (file) => (file.endsWith('.wasm') ? wasmPath : file),
+    });
     let data;
-    // Try to load existing database
     if (fs.existsSync(dbPath)) {
         data = fs.readFileSync(dbPath);
     }
     const sqlite = new SQL.Database(data);
-    // Enable foreign keys
     sqlite.exec('PRAGMA foreign_keys = ON');
-    // Schema bootstrap
     await ensureSqliteSchema(sqlite);
-    // Persist database on changes (sql.js is in-memory by default)
+    persistSqlJsDatabase(sqlite, dbPath);
     const originalExec = sqlite.exec.bind(sqlite);
-    sqlite.exec = function (...args) {
+    sqlite.exec = (...args) => {
+        const [query] = args;
         const result = originalExec(...args);
-        // Save after each exec
-        const data = sqlite.export();
-        fs.writeFileSync(dbPath, Buffer.from(data));
+        if (typeof query === 'string' && shouldPersistSql(query)) {
+            persistSqlJsDatabase(sqlite, dbPath);
+        }
         return result;
     };
-    // Add prepare method for compatibility with drizzle-orm/sql-js
-    sqlite.prepare = (query) => {
-        const stmt = sqlite.prepare(query);
-        const preparedStatement = {};
-        preparedStatement.bind = (bindParams) => {
-            bindParams.forEach((param, index) => {
-                stmt.bind(param, index + 1);
-            });
-            return preparedStatement;
-        };
-        preparedStatement.step = () => {
-            return stmt.step();
-        };
-        preparedStatement.getAsObject = () => {
-            return stmt.getAsObject();
-        };
-        preparedStatement.free = () => {
-            stmt.free();
-        };
-        preparedStatement.run = () => {
-            const result = stmt.step() ? { changes: sqlite.changes() } : { changes: 0 };
-            stmt.reset();
-            return result;
-        };
-        preparedStatement.get = (bindParams = []) => {
-            if (bindParams.length > 0) {
-                preparedStatement.bind(bindParams);
+    if (typeof sqlite.run === 'function') {
+        const originalRun = sqlite.run.bind(sqlite);
+        sqlite.run = (...args) => {
+            const [query] = args;
+            const result = originalRun(...args);
+            if (typeof query === 'string' && shouldPersistSql(query)) {
+                persistSqlJsDatabase(sqlite, dbPath);
             }
-            const row = stmt.step() ? stmt.getAsObject() : undefined;
-            stmt.reset();
-            return row;
-        };
-        preparedStatement.all = (bindParams = []) => {
-            if (bindParams.length > 0) {
-                preparedStatement.bind(bindParams);
-            }
-            const rows = [];
-            while (stmt.step()) {
-                rows.push(stmt.getAsObject());
-            }
-            stmt.reset();
-            return rows;
+            return result;
         };
-        return preparedStatement;
+    }
+    const originalPrepare = sqlite.prepare.bind(sqlite);
+    sqlite.prepare = (query, ...args) => {
+        const stmt = originalPrepare(query, ...args);
+        return wrapSqlJsStatement(stmt, sqlite, dbPath, query);
     };
     logger.info('SQLite initialized with sql.js (pure JavaScript fallback)');
     return drizzle(sqlite, { schema: schemaModule });

package/dist/db/bootstrap.d.ts

@@ -5,5 +5,7 @@ import type { Pool } from 'pg';
  */
 export declare function ensureDataDirectory(): Promise<void>;
 export declare function ensureSqliteSchema(sqlite: Database): Promise<void>;
+export declare function getSchemaVersion(sqlite: Database): Promise<string | null>;
+export declare function runMigrationsForVersion(sqlite: Database, targetVersion: string): Promise<void>;
 export declare function ensurePostgresSchema(pool: Pool): Promise<void>;
 //# sourceMappingURL=bootstrap.d.ts.map