squish-memory 1.0.2 → 1.1.5

package/dist/core/session-hooks/self-iteration-job.js

@@ -20,31 +20,31 @@ const DEFAULT_CONFIG = {
  */
 function buildFactExtractionPrompt(messages) {
     const messagesText = messages.map(m => `[${m.role}]: ${m.content}`).join('\n\n');
-    return `Extract key facts, decisions, and user preferences from this conversation.
-
-Format your response as JSON:
-{
-  "extractedFacts": [
-    {
-      "content": "specific fact text",
-      "type": "fact|decision|preference|observation",
-      "confidence": 0-100
-    }
-  ]
-}
-
-Only extract truly meaningful information that should be remembered:
-- Facts that are useful for future work or decisions
-- User preferences and choices
-- Important decisions made
-- Patterns or behaviors observed
-
-Do NOT extract:
-- Temporary conversational details
-- Greetings or pleasantries
-- Unless they indicate something significant
-
-Conversation messages:
+    return `Extract key facts, decisions, and user preferences from this conversation.
+
+Format your response as JSON:
+{
+  "extractedFacts": [
+    {
+      "content": "specific fact text",
+      "type": "fact|decision|preference|observation",
+      "confidence": 0-100
+    }
+  ]
+}
+
+Only extract truly meaningful information that should be remembered:
+- Facts that are useful for future work or decisions
+- User preferences and choices
+- Important decisions made
+- Patterns or behaviors observed
+
+Do NOT extract:
+- Temporary conversational details
+- Greetings or pleasantries
+- Unless they indicate something significant
+
+Conversation messages:
 ${messagesText}`;
 }
 /**
@@ -52,14 +52,14 @@ ${messagesText}`;
  */
 function buildSummaryPrompt(messages) {
     const messagesText = messages.map(m => `[${m.role}]: ${m.content}`).join('\n\n');
-    return `Generate a concise summary of this conversation (2-3 sentences, under 300 characters).
-
-Focus on:
-- What was accomplished
-- Key decisions made
-- Important context established
-
-Conversation messages:
+    return `Generate a concise summary of this conversation (2-3 sentences, under 300 characters).
+
+Focus on:
+- What was accomplished
+- Key decisions made
+- Important context established
+
+Conversation messages:
 ${messagesText}`;
 }
 /**
@@ -93,8 +93,8 @@ async function getConversationsForIteration(maxMessages) {
     // 3. Have enough messages (messageCount >= minMessageCount)
     const conversations = await sqliteDb.select()
         .from(schema.conversations)
-        .where(sql `${schema.conversations.endedAt} IS NOT NULL
-      AND (${schema.conversations.metadata}->>'selfIterationProcessed') IS NULL
+        .where(sql `${schema.conversations.endedAt} IS NOT NULL
+      AND (${schema.conversations.metadata}->>'selfIterationProcessed') IS NULL
       AND ${schema.conversations.messageCount} >= ?`)
         .limit(10);
     return conversations;

package/dist/core/{cache.js → storage/cache.js}

@@ -1,5 +1,5 @@
-import { config } from '../config.js';
-import { logger } from './logger.js';
+import { config } from '../../config.js';
+import { logger } from '../logger.js';
 let redis = null;
 class LRUCache {
     cache = new Map();

package/dist/core/sync/qmd-sync.d.ts

@@ -1,18 +1,6 @@
 /**
  * QMD Memory Synchronization
- *
- * Syncs Squish memories to QMD collections for hybrid search.
- * Writes memories as markdown files to QMD collection directories.
- *
- * QMD automatically indexes files in collection directories, so we just
- * need to write files to the right location.
- *
- * Collection Structure:
- * - qmd-collections/squish-observations/ - Observation memories
- * - qmd-collections/squish-facts/ - Fact memories
- * - qmd-collections/squish-decisions/ - Decision memories
- * - qmd-collections/squish-context/ - Context memories
- * - qmd-collections/squish-preferences/ - Preference memories
+ * Syncs Squish memories to QMD collections for hybrid search
  */
 import type { MemoryRecord } from '../memory/memories.js';
 export interface CollectionMapping {

package/dist/core/sync/qmd-sync.js

@@ -1,18 +1,6 @@
 /**
  * QMD Memory Synchronization
- *
- * Syncs Squish memories to QMD collections for hybrid search.
- * Writes memories as markdown files to QMD collection directories.
- *
- * QMD automatically indexes files in collection directories, so we just
- * need to write files to the right location.
- *
- * Collection Structure:
- * - qmd-collections/squish-observations/ - Observation memories
- * - qmd-collections/squish-facts/ - Fact memories
- * - qmd-collections/squish-decisions/ - Decision memories
- * - qmd-collections/squish-context/ - Context memories
- * - qmd-collections/squish-preferences/ - Preference memories
+ * Syncs Squish memories to QMD collections for hybrid search
  */
 import { mkdir, writeFile } from 'fs/promises';
 import { join } from 'path';

package/dist/core/toon.d.ts

@@ -0,0 +1,43 @@
+/**
+ * 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
+ * }
+ */
+/**
+ * Compress a memory to TOON format
+ */
+export declare function compressForContext(content: string): string;
+/**
+ * Decompress TOON back to readable format
+ */
+export declare function decompressFromContext(toonString: string): string;
+/**
+ * Estimate compression ratio
+ */
+export declare function estimateCompressionRatio(content: string): number;
+/**
+ * Check if content is JSON
+ */
+export declare function isJson(content: string): boolean;
+/**
+ * Check if content is TOON format
+ */
+export declare function isToon(content: string): boolean;
+/**
+ * Count tokens (rough estimate)
+ */
+export declare function estimateTokens(text: string): number;
+/**
+ * Truncate to token budget
+ */
+export declare function truncateToTokenBudget(content: string, maxTokens: number): string;
+//# sourceMappingURL=toon.d.ts.map

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