squish-memory 1.0.1 → 1.1.5

package/dist/core/toon.js

@@ -0,0 +1,160 @@
+/**
+ * TOON Compression - Token-efficient memory format
+ *
+ * Compact format for memory context using abbreviated notation.
+ * Achieves efficient token usage for context injection.
+ *
+ * Format:
+ * {
+ *   m:[type],      // memory type (1-2 chars)
+ *   c:"...",       // content (truncated)
+ *   t:[],          // tags (array)
+ *   d:123          // days ago
+ * }
+ */
+const MAX_CONTENT_LENGTH = 80; // Max chars per content
+const MAX_TAGS = 3; // Max tags to include
+/**
+ * Compress a memory to TOON format
+ */
+export function compressForContext(content) {
+    // If not JSON or already short, just return
+    if (!isJson(content) || content.length <= MAX_CONTENT_LENGTH) {
+        return content;
+    }
+    try {
+        const parsed = JSON.parse(content);
+        // Build compact TOON object
+        const toon = {
+            m: parsed.type?.substring(0, 2) || 'ob', // observation -> ob
+        };
+        // Truncate content
+        if (parsed.content) {
+            const truncated = parsed.content.substring(0, MAX_CONTENT_LENGTH);
+            toon.c = truncated.length < parsed.content.length ? truncated + '..' : truncated;
+        }
+        // Add tags (limited)
+        if (parsed.tags && Array.isArray(parsed.tags)) {
+            toon.t = parsed.tags.slice(0, MAX_TAGS);
+        }
+        // Add days ago if there's a date
+        if (parsed.createdAt) {
+            const days = Math.floor((Date.now() - new Date(parsed.createdAt).getTime()) / (1000 * 60 * 60 * 24));
+            if (days > 0) {
+                toon.d = days;
+            }
+        }
+        return JSON.stringify(toon);
+    }
+    catch {
+        // Not parseable JSON, return truncated content
+        return content.substring(0, MAX_CONTENT_LENGTH);
+    }
+}
+/**
+ * Decompress TOON back to readable format
+ */
+export function decompressFromContext(toonString) {
+    // Check if it's TOON format
+    if (!isToon(toonString)) {
+        return toonString;
+    }
+    try {
+        const parsed = JSON.parse(toonString);
+        // If it has TOON markers, expand it
+        if (parsed.m || parsed.c || parsed.t) {
+            const typeMap = {
+                ob: 'observation',
+                su: 'success',
+                f: 'failure',
+                fx: 'fix',
+                i: 'insight',
+            };
+            const type = typeMap[parsed.m] || 'observation';
+            const parts = [`[${type}]`];
+            if (parsed.c) {
+                parts.push(parsed.c);
+            }
+            if (parsed.t && parsed.t.length > 0) {
+                parts.push(`#${parsed.t.join(' #')}`);
+            }
+            if (parsed.d) {
+                parts.push(`(${parsed.d}d ago)`);
+            }
+            return parts.join(' ');
+        }
+        return toonString;
+    }
+    catch {
+        // Not valid TOON, return as-is
+        return toonString;
+    }
+}
+/**
+ * Estimate compression ratio
+ */
+export function estimateCompressionRatio(content) {
+    if (!isJson(content) || content.length <= MAX_CONTENT_LENGTH) {
+        return 1.0;
+    }
+    const compressed = compressForContext(content);
+    return compressed.length / content.length;
+}
+/**
+ * Check if content is JSON
+ */
+export function isJson(content) {
+    try {
+        JSON.parse(content);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Check if content is TOON format
+ */
+export function isToon(content) {
+    if (!content.startsWith('{') || !content.endsWith('}')) {
+        return false;
+    }
+    try {
+        const parsed = JSON.parse(content);
+        // Has TOON markers
+        return parsed.m !== undefined || parsed.c !== undefined;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Count tokens (rough estimate)
+ */
+export function estimateTokens(text) {
+    return Math.ceil(text.length / 4);
+}
+/**
+ * Truncate to token budget
+ */
+export function truncateToTokenBudget(content, maxTokens) {
+    const tokens = estimateTokens(content);
+    if (tokens <= maxTokens) {
+        return content;
+    }
+    // Binary search for the right length
+    let low = 0;
+    let high = content.length;
+    while (low < high) {
+        const mid = Math.floor((low + high) / 2);
+        const estimated = estimateTokens(content.substring(0, mid));
+        if (estimated <= maxTokens) {
+            low = mid + 1;
+        }
+        else {
+            high = mid;
+        }
+    }
+    return content.substring(0, low) + '...';
+}
+//# sourceMappingURL=toon.js.map

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

@@ -5,7 +5,7 @@
 import { eq } from 'drizzle-orm';
 import { getDb } from '../../db/index.js';
 import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../database.js';
+import { createDatabaseClient } from '../storage/database.js';
 import { config } from '../../config.js';
 import { logger } from '../logger.js';
 /**

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,6 +1,63 @@
+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');
+    // 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);
+    // Enable foreign keys
+    sqlite.exec('PRAGMA foreign_keys = ON');
+    await ensureSqliteSchema(sqlite);
+    logger.info('SQLite initialized with bun:sqlite');
+    return drizzle(sqlite, { schema: schemaModule });
+}
 export async function createDb() {
     if (config.isTeamMode) {
         return createPostgresDb();
@@ -12,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,
@@ -22,39 +79,46 @@ async function createPostgresDb() {
 }
 async function createSqliteDb() {
     const dbPath = `${getDataDir()}/squish.db`;
-    // Try better-sqlite3 first (best performance)
+    const errors = [];
+    if (isBunRuntime()) {
+        try {
+            return await createBunSqliteDb(dbPath);
+        }
+        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),
+                });
+            }
+        }
+    }
     try {
         return await createBetterSqliteDb(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) {
-            // Both failed - this is critical, Squish cannot work without DB
-            logger.error('CRITICAL: SQLite database initialization failed', {
-                betterSqliteError: betterSqliteError.message,
-                sqlJsError: sqlJsError.message
+    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),
             });
-            throw new Error(`Squish requires SQLite to function. Database initialization failed.\n` +
-                `Primary error (better-sqlite3): ${betterSqliteError.message}\n` +
-                `Fallback error (sql.js): ${sqlJsError.message}\n\n` +
-                `Solutions:\n` +
-                `1. Rebuild native module: npm rebuild better-sqlite3\n` +
-                `2. Install build tools: npm install -g windows-build-tools (Windows)\n` +
-                `3. Or use PostgreSQL instead by setting DATABASE_URL environment variable`);
         }
     }
+    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');
@@ -66,29 +130,44 @@ 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.run('PRAGMA foreign_keys = ON');
-    // Schema bootstrap
+    sqlite.exec('PRAGMA foreign_keys = ON');
     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;
     };
+    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);
+            }
+            return result;
+        };
+    }
+    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 });
 }