squish-memory 1.0.0 → 1.0.2

package/dist/core/memory/hybrid-search.js

@@ -73,22 +73,22 @@ async function bm25Search(input, options) {
         // For empty query with no filters, use "1=1" to match all
         const whereClause = conditions.length > 0 ? conditions.join(' AND ') : '1=1';
         // Build query based on whether we have a search term or not
-        const statement = sqlite.prepare(`
-      SELECT
-        m.id as id,
-        m.project_id as projectId,
-        m.type as type,
-        m.content as content,
-        m.summary as summary,
-        m.tags as tags,
-        m.metadata as metadata,
-        ${isEmptyQuery ? '0 as bm25Score' : 'bm25(memories_fts) as bm25Score'},
-        m.created_at as createdAt
-      FROM memories m
-      ${isEmptyQuery ? '' : 'INNER JOIN memories_fts ON m.rowid = memories_fts.rowid'}
-      WHERE ${whereClause}
-      ${isEmptyQuery ? 'ORDER BY m.created_at DESC' : 'ORDER BY bm25(memories_fts)'}
-      LIMIT ?
+        const statement = sqlite.prepare(`
+      SELECT
+        m.id as id,
+        m.project_id as projectId,
+        m.type as type,
+        m.content as content,
+        m.summary as summary,
+        m.tags as tags,
+        m.metadata as metadata,
+        ${isEmptyQuery ? '0 as bm25Score' : 'bm25(memories_fts) as bm25Score'},
+        m.created_at as createdAt
+      FROM memories m
+      ${isEmptyQuery ? '' : 'INNER JOIN memories_fts ON m.rowid = memories_fts.rowid'}
+      WHERE ${whereClause}
+      ${isEmptyQuery ? 'ORDER BY m.created_at DESC' : 'ORDER BY bm25(memories_fts)'}
+      LIMIT ?
     `);
         const rows = statement.all(...params, limit * 3);
         // Return as ranked results (lower BM25 score = better rank)
@@ -154,22 +154,22 @@ async function vectorSearch(input, options) {
             ? 'WHERE ' + conditions.join(' AND ')
             : '';
         // Fetch candidates for vector search
-        const statement = sqlite.prepare(`
-      SELECT
-        m.id as id,
-        m.project_id as projectId,
-        m.type as type,
-        m.content as content,
-        m.summary as summary,
-        m.tags as tags,
-        m.metadata as metadata,
-        m.embedding as embedding,
-        m.embedding_json as embeddingJson,
-        m.created_at as createdAt
-      FROM memories m
-      ${whereClause}
-      ORDER BY m.created_at DESC
-      LIMIT ?
+        const statement = sqlite.prepare(`
+      SELECT
+        m.id as id,
+        m.project_id as projectId,
+        m.type as type,
+        m.content as content,
+        m.summary as summary,
+        m.tags as tags,
+        m.metadata as metadata,
+        m.embedding as embedding,
+        m.embedding_json as embeddingJson,
+        m.created_at as createdAt
+      FROM memories m
+      ${whereClause}
+      ORDER BY m.created_at DESC
+      LIMIT ?
     `);
         const rows = statement.all(...params, limit * 3);
         // If no embedding available, return results ordered by recency

package/dist/core/memory/memories.js

@@ -1,5 +1,5 @@
 import { randomUUID } from 'crypto';
-import { desc, eq } from 'drizzle-orm';
+import { eq } from 'drizzle-orm';
 import { getDb } from '../../db/index.js';
 import { getSchema } from '../../db/schema.js';
 import { config } from '../../config.js';
@@ -143,14 +143,17 @@ export async function getMemoryById(id, incrementAccess = true) {
 export async function getRecentMemories(projectPath, limit) {
     try {
         const db = createDatabaseClient(await getDb());
-        const schema = await getSchema();
+        const sqlite = db.$client;
         const project = await getProjectByPath(projectPath);
         if (!project)
             return [];
-        const rows = await db.select().from(schema.memories)
-            .where(eq(schema.memories.projectId, project.id))
-            .orderBy(desc(schema.memories.createdAt))
-            .limit(limit);
+        // Use raw SQL to avoid drizzle column name issues
+        const rows = sqlite.prepare(`
+      SELECT * FROM memories 
+      WHERE project_id = ? 
+      ORDER BY created_at DESC 
+      LIMIT ?
+    `).all(project.id, limit);
         return rows.map((row) => normalizeMemory(row));
     }
     catch (error) {
@@ -257,22 +260,22 @@ async function searchMemoriesSqlite(input, tags, limit) {
     const whereClause = conditions.length > 0 ? 'WHERE ' + conditions.join(' AND ') : '';
     // Fetch memories with embeddings for semantic search
     const fetchLimit = Math.max(limit * 3, 50); // Fetch more for re-ranking
-    const statement = sqlite.prepare(`
-    SELECT
-      m.id as id,
-      m.project_id as projectId,
-      m.type as type,
-      m.content as content,
-      m.summary as summary,
-      m.tags as tags,
-      m.metadata as metadata,
-      m.embedding as embedding,
-      m.embedding_json as embeddingJson,
-      m.created_at as createdAt
-    FROM memories m
-    ${whereClause}
-    ORDER BY m.created_at DESC
-    LIMIT ?
+    const statement = sqlite.prepare(`
+    SELECT
+      m.id as id,
+      m.project_id as projectId,
+      m.type as type,
+      m.content as content,
+      m.summary as summary,
+      m.tags as tags,
+      m.metadata as metadata,
+      m.embedding as embedding,
+      m.embedding_json as embeddingJson,
+      m.created_at as createdAt
+    FROM memories m
+    ${whereClause}
+    ORDER BY m.created_at DESC
+    LIMIT ?
   `);
     const rows = statement.all(...params, fetchLimit);
     if (rows.length === 0)
@@ -326,42 +329,42 @@ async function searchMemoriesPostgres(input, tags, limit) {
     const whereClause = whereParts.length ? `WHERE ${whereParts.join(' AND ')}` : '';
     const embedding = await getEmbedding(input.query);
     if (embedding) {
-        const rows = await db.$client.query(`SELECT
-       id,
-       project_id as "projectId",
-       type,
-       content,
-       summary,
-       tags,
-       metadata,
-       created_at as "createdAt",
-       valid_from as "validFrom",
-       valid_to as "validTo",
-       recorded_at as "recordedAt"
-     FROM memories
-     ${whereClause}
-     ORDER BY created_at DESC
+        const rows = await db.$client.query(`SELECT
+       id,
+       project_id as "projectId",
+       type,
+       content,
+       summary,
+       tags,
+       metadata,
+       created_at as "createdAt",
+       valid_from as "validFrom",
+       valid_to as "validTo",
+       recorded_at as "recordedAt"
+     FROM memories
+     ${whereClause}
+     ORDER BY created_at DESC
      LIMIT $${values.length + 1}`, [...values, limit]);
         return rows.rows.map((row) => ({
             ...normalizeMemory(row),
             similarity: row.similarity ?? 0,
         }));
     }
-    const rows = await db.$client.query(`SELECT
-       id,
-       project_id as "projectId",
-       type,
-       content,
-       summary,
-       tags,
-       metadata,
-       created_at as "createdAt",
-       valid_from as "validFrom",
-       valid_to as "validTo",
-       recorded_at as "recordedAt"
-     FROM memories
-     ${whereClause}
-     ORDER BY created_at DESC
+    const rows = await db.$client.query(`SELECT
+       id,
+       project_id as "projectId",
+       type,
+       content,
+       summary,
+       tags,
+       metadata,
+       created_at as "createdAt",
+       valid_from as "validFrom",
+       valid_to as "validTo",
+       recorded_at as "recordedAt"
+     FROM memories
+     ${whereClause}
+     ORDER BY created_at DESC
      LIMIT $${values.length + 1}`, [...values, limit]);
     return rows.rows.map((row) => ({
         ...normalizeMemory(row),

package/dist/core/memory/query-rewriter.js

@@ -2,15 +2,15 @@
 import { logger } from '../logger.js';
 import { config } from '../../config.js';
 import { expandQuery } from './query-processor.js';
-const REWRITE_SYSTEM_PROMPT = `You are a search query optimizer. Given a conversation context and a user's latest message, rewrite the message into the single most effective search query to retrieve relevant memories.
-
-Rules:
-1. Output ONLY the optimized search query - no explanations or extra text
-2. Remove filler words (please, can you, etc.)
-3. Focus on the core information need
-4. Preserve important entities (names, dates, technical terms)
-5. Add synonyms for key terms if helpful
-6. Consider what memories would be most relevant
+const REWRITE_SYSTEM_PROMPT = `You are a search query optimizer. Given a conversation context and a user's latest message, rewrite the message into the single most effective search query to retrieve relevant memories.
+
+Rules:
+1. Output ONLY the optimized search query - no explanations or extra text
+2. Remove filler words (please, can you, etc.)
+3. Focus on the core information need
+4. Preserve important entities (names, dates, technical terms)
+5. Add synonyms for key terms if helpful
+6. Consider what memories would be most relevant
 7. If the message is about recalling something specific, include those details`;
 export async function rewriteQuery(query, context) {
     if (!config.queryRewritingEnabled) {

package/dist/core/memory/stats.js

@@ -36,11 +36,11 @@ export async function getMemoryStats(projectPath = process.cwd()) {
         // Count by type
         if (config.isTeamMode) {
             // PostgreSQL - use raw query for GROUP BY
-            const typeCounts = await db.execute(sql `
-        SELECT type, COUNT(*) as count
-        FROM memories
-        ${project ? sql `WHERE project_id = ${project.id}` : sql ``}
-        GROUP BY type
+            const typeCounts = await db.execute(sql `
+        SELECT type, COUNT(*) as count
+        FROM memories
+        ${project ? sql `WHERE project_id = ${project.id}` : sql ``}
+        GROUP BY type
       `);
             for (const row of typeCounts.rows) {
                 stats.byType[row.type] = Number(row.count);

package/dist/core/namespaces/index.js

@@ -15,7 +15,8 @@ export async function createNamespace(input) {
     const schema = await getSchema();
     const id = randomUUID();
     // Check if namespace with same name exists under parent
-    const existing = await db.select()
+    const sqliteDb = db;
+    const existing = await sqliteDb.select()
         .from(schema.namespaces)
         .where(and(eq(schema.namespaces.projectId, input.projectId), eq(schema.namespaces.name, input.name), input.parentId
         ? eq(schema.namespaces.parentId, input.parentId)
@@ -26,7 +27,7 @@ export async function createNamespace(input) {
     }
     // Build namespace path
     const path = await buildNamespacePath(input.projectId, input.name, input.parentId ?? null);
-    await db.insert(schema.namespaces).values({
+    await sqliteDb.insert(schema.namespaces).values({
         id,
         projectId: input.projectId,
         name: input.name,
@@ -58,7 +59,8 @@ async function buildNamespacePath(projectId, name, parentId) {
     }
     const db = await getDb();
     const schema = await getSchema();
-    const [parent] = await db.select()
+    const sqliteDb = db;
+    const [parent] = await sqliteDb.select()
         .from(schema.namespaces)
         .where(eq(schema.namespaces.id, parentId))
         .limit(1);
@@ -75,7 +77,8 @@ export async function getNamespaceById(id) {
     if (!db)
         return null;
     const schema = await getSchema();
-    const [row] = await db.select()
+    const sqliteDb = db;
+    const [row] = await sqliteDb.select()
         .from(schema.namespaces)
         .where(eq(schema.namespaces.id, id))
         .limit(1);
@@ -104,11 +107,12 @@ export async function resolveNamespacePath(projectId, path) {
     if (!db)
         return null;
     const schema = await getSchema();
+    const sqliteDb = db;
     let parentId = null;
     let targetNamespace = null;
     // Traverse path segments
     for (const segment of path) {
-        const [result] = await db.select()
+        const [result] = await sqliteDb.select()
             .from(schema.namespaces)
             .where(and(eq(schema.namespaces.projectId, projectId), eq(schema.namespaces.name, segment), parentId
             ? eq(schema.namespaces.parentId, parentId)
@@ -129,8 +133,9 @@ export async function getNamespaceTree(projectId) {
     if (!db)
         return [];
     const schema = await getSchema();
+    const sqliteDb = db;
     // Get all namespaces for project
-    const all = await db.select()
+    const all = await sqliteDb.select()
         .from(schema.namespaces)
         .where(eq(schema.namespaces.projectId, projectId))
         .orderBy(schema.namespaces.name);
@@ -167,6 +172,7 @@ export async function getDefaultNamespaces(projectId) {
     if (!db)
         return [];
     const schema = await getSchema();
+    const sqliteDb = db;
     const created = [];
     const defaults = [
         { name: 'user', type: 'user', description: 'User-specific memories and preferences' },
@@ -175,7 +181,7 @@ export async function getDefaultNamespaces(projectId) {
     ];
     const defaultNames = ['user', 'agent', 'project'];
     // Check all default namespaces at once with IN clause
-    const existing = await db.select()
+    const existing = await sqliteDb.select()
         .from(schema.namespaces)
         .where(and(eq(schema.namespaces.projectId, projectId), eq(schema.namespaces.name, defaultNames[0]), eq(schema.namespaces.type, 'user'), isNull(schema.namespaces.parentId)));
     if (existing.length > 0) {
@@ -199,7 +205,7 @@ export async function getDefaultNamespaces(projectId) {
     }
     // Check remaining defaults sequentially (agent and project)
     for (const defName of defaultNames.slice(1)) {
-        const existing = await db.select()
+        const existing = await sqliteDb.select()
             .from(schema.namespaces)
             .where(and(eq(schema.namespaces.projectId, projectId), eq(schema.namespaces.name, defName), eq(schema.namespaces.type, defName), isNull(schema.namespaces.parentId)))
             .limit(1);
@@ -237,6 +243,7 @@ export async function listNamespaces(options = {}) {
     if (!db)
         return [];
     const schema = await getSchema();
+    const sqliteDb = db;
     const conditions = [];
     if (options.projectId) {
         conditions.push(eq(schema.namespaces.projectId, options.projectId));
@@ -252,7 +259,7 @@ export async function listNamespaces(options = {}) {
             conditions.push(eq(schema.namespaces.parentId, options.parentId));
         }
     }
-    const rows = await db.select()
+    const rows = await sqliteDb.select()
         .from(schema.namespaces)
         .where(conditions.length > 0 ? and(...conditions) : undefined)
         .orderBy(schema.namespaces.name);
@@ -276,7 +283,8 @@ export async function deleteNamespace(id) {
     if (!db)
         return;
     const schema = await getSchema();
-    await db.delete(schema.namespaces).where(eq(schema.namespaces.id, id));
+    const sqliteDb = db;
+    await sqliteDb.delete(schema.namespaces).where(eq(schema.namespaces.id, id));
     logger.info(`[Namespaces] Deleted namespace: ${id}`);
 }
 /**
@@ -287,7 +295,8 @@ export async function updateNamespace(id, updates) {
     if (!db)
         return;
     const schema = await getSchema();
-    await db.update(schema.namespaces).set({
+    const sqliteDb = db;
+    await sqliteDb.update(schema.namespaces).set({
         ...updates,
         updatedAt: new Date(),
     }).where(eq(schema.namespaces.id, id));

package/dist/core/scheduler/cron-scheduler.js

@@ -26,7 +26,8 @@ export async function initializeScheduler() {
     }
     try {
         await ensureDefaultJobs(db);
-        const jobs = await db
+        const sqliteDb = db;
+        const jobs = await sqliteDb
             .select()
             .from(maintenanceJobs)
             .where(eq(maintenanceJobs.enabled, true));
@@ -64,18 +65,61 @@ async function ensureDefaultJobs(db) {
         },
     ];
     for (const job of defaultJobs) {
-        const existing = await db
-            .select()
-            .from(maintenanceJobs)
-            .where(eq(maintenanceJobs.jobName, job.jobName))
-            .limit(1);
+        let existing;
+        try {
+            existing = await db
+                .select()
+                .from(maintenanceJobs)
+                .where(eq(maintenanceJobs.jobName, job.jobName))
+                .limit(1);
+        }
+        catch (queryError) {
+            logger.error(`[Scheduler] Query failed for job ${job.jobName}:`, queryError.message);
+            // Try raw SQL fallback
+            try {
+                const rawDb = db.$client;
+                if (rawDb && typeof rawDb.prepare === 'function') {
+                    existing = rawDb.prepare('SELECT * FROM maintenance_jobs WHERE job_name = ?').all(job.jobName);
+                }
+            }
+            catch (fallbackError) {
+                logger.error(`[Scheduler] Fallback query also failed:`, fallbackError.message);
+                throw queryError;
+            }
+        }
         if (existing.length === 0) {
-            await db.insert(maintenanceJobs).values({
-                ...job,
-                totalRuns: 0,
-                successCount: 0,
-                failureCount: 0,
-            });
+            try {
+                await db.insert(maintenanceJobs).values({
+                    jobName: job.jobName,
+                    jobType: job.jobType,
+                    cronExpression: job.cronExpression,
+                    enabled: job.enabled,
+                    jobConfig: job.jobConfig,
+                    totalRuns: 0,
+                    successCount: 0,
+                    failureCount: 0,
+                    lastRunAt: null,
+                    nextRunAt: null,
+                    lastRunDuration: null,
+                    lastRunStatus: null,
+                    lastRunError: null,
+                });
+            }
+            catch (insertError) {
+                // Fallback to raw SQL if drizzle insert fails
+                logger.warn(`[Scheduler] Drizzle insert failed, using raw SQL: ${insertError.message}`);
+                const rawDb = db.$client;
+                if (rawDb && typeof rawDb.prepare === 'function') {
+                    const stmt = rawDb.prepare(`
+            INSERT INTO maintenance_jobs 
+            (id, job_name, job_type, cron_expression, enabled, job_config, 
+             total_runs, success_count, failure_count, last_run_at, next_run_at, 
+             last_run_duration, last_run_status, last_run_error)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+          `);
+                    stmt.run(crypto.randomUUID(), job.jobName, job.jobType, job.cronExpression, job.enabled ? 1 : 0, JSON.stringify(job.jobConfig), 0, 0, 0, null, null, null, null, null);
+                }
+            }
             logger.info(`[Scheduler] Created default job: ${job.jobName}`);
             // Register self-iteration handler
             if (job.jobName === 'self_iteration') {
@@ -108,12 +152,13 @@ export async function scheduleJob(job) {
     const nextRun = getNextRunTime(job.cronExpression);
     const db = await getDb();
     if (db) {
-        await db
+        const sqliteDb = db;
+        await sqliteDb
             .update(maintenanceJobs)
             .set({ nextRunAt: nextRun })
             .where(eq(maintenanceJobs.id, job.id));
     }
-    logger.info(`[Scheduler] Scheduled ${job.jobName} with cron: ${job.cronExpression}, next run: ${nextRun?.toISOString()}`);
+    logger.info(`[Scheduler] Scheduled ${job.jobName} with cron: ${job.cronExpression}${nextRun ? `, next run: ${nextRun.toISOString()}` : ''}`);
 }
 export async function executeJob(job) {
     const db = await getDb();
@@ -147,11 +192,12 @@ export async function executeJob(job) {
     }
     const completedAt = new Date();
     if (db) {
-        const [currentJob] = await db
+        const sqliteDb = db;
+        const [currentJob] = await sqliteDb
             .select()
             .from(maintenanceJobs)
             .where(eq(maintenanceJobs.id, job.id));
-        await db
+        await sqliteDb
             .update(maintenanceJobs)
             .set({
             lastRunAt: startedAt,
@@ -164,7 +210,7 @@ export async function executeJob(job) {
             nextRunAt: job.cronExpression ? getNextRunTime(job.cronExpression) : null,
         })
             .where(eq(maintenanceJobs.id, job.id));
-        await db.insert(maintenanceJobHistory).values({
+        await sqliteDb.insert(maintenanceJobHistory).values({
             jobId: job.id,
             startedAt,
             completedAt,
@@ -180,13 +226,23 @@ function getNextRunTime(cronExpression) {
     try {
         const now = new Date();
         const parts = cronExpression.split(' ');
-        if (parts[2] === '*' && parts[3] === '*' && parts[4] === '*') {
+        // Daily jobs: MM HH * * *
+        if (parts[2] === '*' && parts[3] === '*' && parts[4] === '*' && parts[1] !== '*') {
             const next = new Date(now);
             next.setHours(parseInt(parts[1]), parseInt(parts[0]), 0, 0);
             if (next <= now)
                 next.setDate(next.getDate() + 1);
             return next;
         }
+        // Hourly jobs: MM * * * *
+        if (parts[1] === '*' && parts[2] === '*' && parts[3] === '*' && parts[4] === '*') {
+            const next = new Date(now);
+            next.setMinutes(parseInt(parts[0]), 0, 0);
+            if (next <= now)
+                next.setHours(next.getHours() + 1);
+            return next;
+        }
+        // Weekly jobs: MM HH * * D
         if (parts[4] !== '*') {
             const dayOfWeek = parseInt(parts[4]);
             const next = new Date(now);
@@ -205,7 +261,8 @@ export async function getScheduledJobs() {
     const db = await getDb();
     if (!db)
         return [];
-    const jobs = await db.select().from(maintenanceJobs);
+    const sqliteDb = db;
+    const jobs = await sqliteDb.select().from(maintenanceJobs);
     return jobs.map((job) => ({
         id: job.id,
         jobName: job.jobName,
@@ -222,7 +279,8 @@ export async function getOverdueJobs() {
     if (!db)
         return [];
     const now = new Date();
-    const jobs = await db.select().from(maintenanceJobs);
+    const sqliteDb = db;
+    const jobs = await sqliteDb.select().from(maintenanceJobs);
     return jobs
         .filter((job) => {
         if (!job.enabled)

package/dist/core/scheduler/job-runner.js

@@ -113,7 +113,8 @@ async function boostFrequentlyAccessed() {
     const db = await getDb();
     if (!db)
         return 0;
-    const frequentlyAccessed = await db
+    const sqliteDb = db;
+    const frequentlyAccessed = await sqliteDb
         .select()
         .from(memories)
         .where(gt(memories.accessCount, 3));
@@ -121,7 +122,7 @@ async function boostFrequentlyAccessed() {
     for (const memory of frequentlyAccessed) {
         const currentPriority = memory.retrievalPriority ?? 50;
         const newPriority = Math.min(100, currentPriority + 5);
-        await db
+        await sqliteDb
             .update(memories)
             .set({ retrievalPriority: newPriority })
             .where(eq(memories.id, memory.id));
@@ -134,13 +135,14 @@ async function archiveStaleMemories(daysOld) {
     if (!db)
         return 0;
     const staleThreshold = new Date(Date.now() - daysOld * 24 * 60 * 60 * 1000);
-    const staleMemories = await db
+    const sqliteDb = db;
+    const staleMemories = await sqliteDb
         .select()
         .from(memories)
         .where(and(lt(memories.lastAccessedAt, staleThreshold), lt(memories.importanceScore, 30), eq(memories.isProtected, false), eq(memories.isPinned, false)));
     let archived = 0;
     for (const memory of staleMemories) {
-        await db
+        await sqliteDb
             .update(memories)
             .set({ tier: 'cold' })
             .where(eq(memories.id, memory.id));
@@ -153,7 +155,8 @@ async function cleanupOldFeedbackRecords(daysOld) {
     if (!db)
         return 0;
     const oldThreshold = new Date(Date.now() - daysOld * 24 * 60 * 60 * 1000);
-    await db
+    const sqliteDb = db;
+    await sqliteDb
         .delete(memoryFeedback)
         .where(lt(memoryFeedback.createdAt, oldThreshold));
     return 0;