squish-memory 1.0.1 → 1.1.5

package/dist/core/search/conversations.js

@@ -2,10 +2,10 @@ import { and, desc, eq, gte, lte } from 'drizzle-orm';
 import { getDb } from '../../db/index.js';
 import { getSchema } from '../../db/schema.js';
 import { config } from '../../config.js';
-import { getProjectByPath } from '../../core/projects.js';
-import { fromSqliteJson } from '../../core/memory/serialization.js';
-import { createDatabaseClient } from '../../core/database.js';
-import { normalizeTimestamp, clampLimit } from '../../core/utils.js';
+import { requireProject } from '../../core/projects.js';
+import { deserializeMetadata } from '../../core/memory/serialization.js';
+import { createDatabaseClient } from '../storage/database.js';
+import { normalizeTimestamp, clampLimit } from '../lib/utils.js';
 export async function searchConversations(input) {
     const limit = clampLimit(input.limit, 5, 1, 50);
     if (config.isTeamMode) {
@@ -19,10 +19,8 @@ export async function getRecentConversations(input) {
     const limit = clampLimit(input.n, 3, 1, 50);
     const whereParts = [];
     if (input.project) {
-        const project = await getProjectByPath(input.project);
-        if (project) {
-            whereParts.push(eq(schema.conversations.projectId, project.id));
-        }
+        const project = await requireProject(input.project);
+        whereParts.push(eq(schema.conversations.projectId, project.id));
     }
     if (input.before) {
         whereParts.push(lte(schema.conversations.startedAt, new Date(input.before)));
@@ -46,24 +44,24 @@ async function searchConversationsSqlite(input, limit) {
         params.push(input.role);
     }
     params.push(limit);
-    const statement = sqlite.prepare(`
-    SELECT DISTINCT
-      c.id as id,
-      c.project_id as projectId,
-      c.session_id as sessionId,
-      c.title as title,
-      c.summary as summary,
-      c.message_count as messageCount,
-      c.token_count as tokenCount,
-      c.started_at as startedAt,
-      c.ended_at as endedAt,
-      c.metadata as metadata
-    FROM conversations c
-    JOIN messages m ON m.conversation_id = c.id
-    JOIN messages_fts ON messages_fts.rowid = m.rowid
-    WHERE ${where}
-    ORDER BY c.started_at DESC
-    LIMIT ?
+    const statement = sqlite.prepare(`
+    SELECT DISTINCT
+      c.id as id,
+      c.project_id as projectId,
+      c.session_id as sessionId,
+      c.title as title,
+      c.summary as summary,
+      c.message_count as messageCount,
+      c.token_count as tokenCount,
+      c.started_at as startedAt,
+      c.ended_at as endedAt,
+      c.metadata as metadata
+    FROM conversations c
+    JOIN messages m ON m.conversation_id = c.id
+    JOIN messages_fts ON messages_fts.rowid = m.rowid
+    WHERE ${where}
+    ORDER BY c.started_at DESC
+    LIMIT ?
   `);
     const rows = statement.all(...params);
     return rows.map((row) => normalizeConversation(row));
@@ -77,26 +75,26 @@ async function searchConversationsPostgres(input, limit) {
         whereParts.push(`m.role = $${values.length}`);
     }
     values.push(limit);
-    const rows = await db.$client.query(`SELECT DISTINCT ON (c.id)
-      c.id as "id",
-      c.project_id as "projectId",
-      c.session_id as "sessionId",
-      c.title as "title",
-      c.summary as "summary",
-      c.message_count as "messageCount",
-      c.token_count as "tokenCount",
-      c.started_at as "startedAt",
-      c.ended_at as "endedAt",
-      c.metadata as "metadata"
-    FROM conversations c
-    JOIN messages m ON m.conversation_id = c.id
-    WHERE ${whereParts.join(' AND ')}
-    ORDER BY c.id, c.started_at DESC
+    const rows = await db.$client.query(`SELECT DISTINCT ON (c.id)
+      c.id as "id",
+      c.project_id as "projectId",
+      c.session_id as "sessionId",
+      c.title as "title",
+      c.summary as "summary",
+      c.message_count as "messageCount",
+      c.token_count as "tokenCount",
+      c.started_at as "startedAt",
+      c.ended_at as "endedAt",
+      c.metadata as "metadata"
+    FROM conversations c
+    JOIN messages m ON m.conversation_id = c.id
+    WHERE ${whereParts.join(' AND ')}
+    ORDER BY c.id, c.started_at DESC
     LIMIT $${values.length}`, values);
     return rows.rows.map((row) => normalizeConversation(row));
 }
 function normalizeConversation(row) {
-    const metadata = config.isTeamMode ? row.metadata : fromSqliteJson(row.metadata ?? null);
+    const metadata = deserializeMetadata(row.metadata ?? null);
     return {
         id: row.id,
         projectId: row.projectId ?? row.project_id ?? null,

package/dist/core/search/entities.js

@@ -1,17 +1,14 @@
 import { desc, eq } from 'drizzle-orm';
 import { getDb } from '../../db/index.js';
 import { getSchema } from '../../db/schema.js';
-import { config } from '../../config.js';
-import { getProjectByPath } from '../../core/projects.js';
-import { fromSqliteJson } from '../../core/memory/serialization.js';
-import { createDatabaseClient } from '../../core/database.js';
-import { normalizeTimestamp } from '../../core/utils.js';
+import { requireProject } from '../../core/projects.js';
+import { deserializeMetadata } from '../../core/memory/serialization.js';
+import { createDatabaseClient } from '../storage/database.js';
+import { normalizeTimestamp } from '../lib/utils.js';
 export async function getEntitiesForProject(projectPath, limit) {
     const db = createDatabaseClient(await getDb());
     const schema = await getSchema();
-    const project = await getProjectByPath(projectPath);
-    if (!project)
-        return [];
+    const project = await requireProject(projectPath);
     const rows = await db.select().from(schema.entities)
         .where(eq(schema.entities.projectId, project.id))
         .orderBy(desc(schema.entities.createdAt))
@@ -19,7 +16,7 @@ export async function getEntitiesForProject(projectPath, limit) {
     return rows.map((row) => normalizeEntity(row));
 }
 function normalizeEntity(row) {
-    const properties = config.isTeamMode ? row.properties : fromSqliteJson(row.properties ?? null);
+    const properties = deserializeMetadata(row.properties ?? null);
     return {
         id: row.id,
         projectId: row.projectId ?? row.project_id ?? null,

package/dist/core/search/graph-boost.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Compute a simple graph boost for a set of memory IDs.
+ * For each memory, sum (weight * coactivationCount) of outgoing associations.
+ * Returns a map from memoryId to boost value (default 0).
+ */
+export declare function computeGraphBoost(memoryIds: string[]): Promise<Record<string, number>>;
+//# sourceMappingURL=graph-boost.d.ts.map

package/dist/core/search/graph-boost.js

@@ -0,0 +1,23 @@
+import { getDb } from '../../db/index.js';
+import { memoryAssociations } from '../../db/drizzle/schema.js';
+import { inArray } from 'drizzle-orm';
+/**
+ * Compute a simple graph boost for a set of memory IDs.
+ * For each memory, sum (weight * coactivationCount) of outgoing associations.
+ * Returns a map from memoryId to boost value (default 0).
+ */
+export async function computeGraphBoost(memoryIds) {
+    const boost = {};
+    if (memoryIds.length === 0)
+        return boost;
+    const db = await getDb();
+    // @ts-ignore - drizzle overload
+    const rows = await db.select().from(memoryAssociations).where(inArray(memoryAssociations.fromMemoryId, memoryIds));
+    for (const row of rows) {
+        const from = row.fromMemoryId;
+        const val = (row.weight ?? 0) * (row.coactivationCount ?? 0);
+        boost[from] = (boost[from] ?? 0) + val;
+    }
+    return boost;
+}
+//# sourceMappingURL=graph-boost.js.map

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

@@ -15,7 +15,7 @@
  * GitHub: https://github.com/tobi/qmd
  */
 import { getQMDClient } from '../embeddings/qmd-client.js';
-import { searchMemories } from '../memory/memories.js';
+import { search } from '../memory/memories.js';
 import { logger } from '../logger.js';
 import { config } from '../../config.js';
 /**
@@ -29,7 +29,7 @@ export async function searchWithQMD(options) {
     if (!(await client.isAvailable())) {
         logger.warn('QMD unavailable, falling back to Squish search');
         // Fallback to Squish search
-        const squishResults = await searchMemories(options);
+        const squishResults = await search(options);
         return squishResults.map((r) => ({
             ...r,
             source: 'squish'
@@ -73,7 +73,7 @@ export async function searchWithQMD(options) {
     catch (error) {
         logger.error(`QMD search failed: ${error}`);
         // Fallback to Squish search
-        const squishResults = await searchMemories(options);
+        const squishResults = await search(options);
         return squishResults.map((r) => ({
             ...r,
             source: 'squish'
@@ -93,7 +93,7 @@ export async function fusedSearch(options) {
     const qmdAvailable = await client.isAvailable();
     // Run searches in parallel
     const results = await Promise.allSettled([
-        searchMemories(options),
+        search(options),
         qmdAvailable ? searchWithQMD({ ...options, includeSquishResults: false }) : []
     ]);
     const squishResults = results[0].status === 'fulfilled'

package/dist/core/security/encrypt.d.ts

@@ -0,0 +1,6 @@
+export declare function encrypt(plain: string, passphrase?: string): {
+    ciphertext: string;
+    nonce: string;
+};
+export declare function decrypt(ciphertext: string, nonceB64: string, passphrase?: string): string;
+//# sourceMappingURL=encrypt.d.ts.map

package/dist/core/security/encrypt.js

@@ -0,0 +1,47 @@
+import { randomBytes, pbkdf2Sync, createCipheriv, createDecipheriv } from 'crypto';
+import { config } from '../../config.js';
+const ITERATIONS = 100_000;
+const KEY_LEN = 32; // 256-bit
+const DIGEST = 'sha256';
+const ALGO = 'aes-256-gcm';
+const NONCE_LEN = 12;
+/**
+ * Derive a symmetric key from the passphrase and a salt.
+ * The salt is stored in `.squish/salt` (plain text) and is generated once.
+ */
+function getSalt() {
+    const fs = require('fs');
+    const path = require('path');
+    const saltPath = path.join(config.dataDir, 'salt');
+    if (!fs.existsSync(saltPath)) {
+        const salt = randomBytes(16).toString('hex');
+        fs.writeFileSync(saltPath, salt);
+        return Buffer.from(salt, 'hex');
+    }
+    return Buffer.from(fs.readFileSync(saltPath, 'utf-8'), 'hex');
+}
+function deriveKey(passphrase) {
+    const salt = getSalt();
+    return pbkdf2Sync(passphrase, salt, ITERATIONS, KEY_LEN, DIGEST);
+}
+export function encrypt(plain, passphrase) {
+    const key = deriveKey(passphrase || config.encryptionPassphrase);
+    const nonce = randomBytes(NONCE_LEN);
+    const cipher = createCipheriv(ALGO, key, nonce);
+    const encrypted = Buffer.concat([cipher.update(plain, 'utf8'), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    const ciphertext = Buffer.concat([encrypted, tag]).toString('base64');
+    return { ciphertext, nonce: nonce.toString('base64') };
+}
+export function decrypt(ciphertext, nonceB64, passphrase) {
+    const key = deriveKey(passphrase || config.encryptionPassphrase);
+    const nonce = Buffer.from(nonceB64, 'base64');
+    const data = Buffer.from(ciphertext, 'base64');
+    const tag = data.slice(data.length - 16);
+    const encrypted = data.slice(0, data.length - 16);
+    const decipher = createDecipheriv(ALGO, key, nonce);
+    decipher.setAuthTag(tag);
+    const decrypted = Buffer.concat([decipher.update(encrypted), decipher.final()]);
+    return decrypted.toString('utf8');
+}
+//# sourceMappingURL=encrypt.js.map

package/dist/core/{governance.d.ts → security/governance.d.ts}

@@ -16,6 +16,11 @@ export declare function pinMemory(memoryId: string): Promise<void>;
 export declare function unpinMemory(memoryId: string): Promise<void>;
 /**
  * Get all pinned memories for auto-injection into context
+ * Works regardless of governance settings - pinned memories should always be accessible
  */
-export declare function getPinnedMemories(): Promise<any[]>;
+export declare function getPinnedMemories(projectId?: string): Promise<any[]>;
+/**
+ * Get pinned memories formatted for context injection
+ */
+export declare function getPinnedMemoriesForContext(projectId?: string): Promise<string[]>;
 //# sourceMappingURL=governance.d.ts.map

package/dist/core/security/governance.js

@@ -0,0 +1,79 @@
+/**
+ * Memory Governance
+ * Implements protection, pinning, and immutability rules
+ */
+import { eq } from 'drizzle-orm';
+import { getDb } from '../../db/index.js';
+import { getSchema } from '../../db/schema.js';
+import { performMemoryOperation } from '../utils/memory-operations.js';
+import { logger } from '../logger.js';
+import { createDatabaseClient } from '../storage/database.js';
+/**
+ * Mark a memory as protected (cannot be evicted)
+ */
+export async function protectMemory(memoryId, reason) {
+    await performMemoryOperation(memoryId, {
+        name: 'protecting memory',
+        updates: {
+            isProtected: true,
+            metadata: { protectionReason: reason, protectedAt: new Date().toISOString() },
+        },
+    });
+}
+/**
+ * Pin a memory for automatic injection into context
+ */
+export async function pinMemory(memoryId) {
+    const db = createDatabaseClient(await getDb());
+    const schema = await getSchema();
+    await db
+        .update(schema.memories)
+        .set({
+        isPinned: true,
+        importanceScore: 100,
+        lastImportanceRecalc: new Date(),
+    })
+        .where(eq(schema.memories.id, memoryId));
+}
+/**
+ * Unpin a memory
+ */
+export async function unpinMemory(memoryId) {
+    const db = createDatabaseClient(await getDb());
+    const schema = await getSchema();
+    await db
+        .update(schema.memories)
+        .set({
+        isPinned: false,
+        lastImportanceRecalc: new Date(),
+    })
+        .where(eq(schema.memories.id, memoryId));
+}
+/**
+ * Get all pinned memories for auto-injection into context
+ * Works regardless of governance settings - pinned memories should always be accessible
+ */
+export async function getPinnedMemories(projectId) {
+    try {
+        const db = await getDb();
+        const schema = await getSchema();
+        let query = db
+            .select()
+            .from(schema.memories)
+            .where(eq(schema.memories.isPinned, true))
+            .limit(50);
+        return await query;
+    }
+    catch (error) {
+        logger.error('Error retrieving pinned memories', error);
+        return [];
+    }
+}
+/**
+ * Get pinned memories formatted for context injection
+ */
+export async function getPinnedMemoriesForContext(projectId) {
+    const pinned = await getPinnedMemories(projectId);
+    return pinned.map(m => `[Pinned] ${m.content?.substring(0, 500) || '(no content)'}`);
+}
+//# sourceMappingURL=governance.js.map

package/dist/core/session/auto-load.js

@@ -1,10 +1,10 @@
 /** Session Auto-Load - Automatically load context when MCP session initializes */
 import { logger } from '../logger.js';
 import { config } from '../../config.js';
-import { initializeCoreMemory, getCoreMemory } from '../core-memory.js';
-import { searchMemories } from '../memory/memories.js';
-import { getProjectContext } from '../context.js';
-import { ensureProject } from '../projects.js';
+import { initializeCoreMemory, getCoreMemory } from '../ingestion/core-memory.js';
+import { search } from '../memory/memories.js';
+import { getProjectContext } from '../context/context.js';
+import { getOrCreateProject } from '../projects.js';
 import { DEFAULT_AUTO_LOAD_CONFIG } from './types.js';
 function estimateTokens(text) {
     return Math.ceil(text.length / 4);
@@ -26,7 +26,7 @@ export async function performAutoLoad(projectPath, customConfig) {
         return result;
     }
     try {
-        const project = await ensureProject(projectPath);
+        const project = await getOrCreateProject(projectPath);
         if (!project) {
             result.warnings.push(`Failed to create/find project: ${projectPath}`);
             result.duration = Date.now() - startTime;
@@ -52,7 +52,7 @@ export async function performAutoLoad(projectPath, customConfig) {
         }
         if (cfg.includeRecentMemories && cfg.recentMemoryCount > 0) {
             try {
-                const recentMemories = await searchMemories({
+                const recentMemories = await search({
                     query: '',
                     project: projectPath,
                     limit: cfg.recentMemoryCount,

package/dist/core/session/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * Session Module
- * v0.10.0 - Session management and auto-load
+ * Session management and auto-load
  */
 export * from './types.js';
 export * from './auto-load.js';

package/dist/core/session/index.js

@@ -1,6 +1,6 @@
 /**
  * Session Module
- * v0.10.0 - Session management and auto-load
+ * Session management and auto-load
  */
 export * from './types.js';
 export * from './auto-load.js';

package/dist/core/session/self-iteration-job.d.ts

@@ -0,0 +1,20 @@
+/** Self-Iteration Job - Auto-extract key facts from ended conversations
+ *
+ * Processes conversations to extract memories and generate summaries
+ */
+import { type JobHandler } from '../scheduler/cron-scheduler.js';
+export interface SelfIterationConfig {
+    enabled: boolean;
+    extractFacts: boolean;
+    generateSummaries: boolean;
+    consolidateMemories: boolean;
+    minMessageCount: number;
+    maxMessagesToProcess: number;
+}
+declare const DEFAULT_CONFIG: SelfIterationConfig;
+/**
+ * Register self-iteration job handler
+ */
+declare const selfIterationHandler: JobHandler;
+export { selfIterationHandler, DEFAULT_CONFIG };
+//# sourceMappingURL=self-iteration-job.d.ts.map