squish-memory 1.0.2 → 1.2.0

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-wrapper.d.ts

@@ -0,0 +1,36 @@
+import { type QMDSearchResult } from '../embeddings/qmd-client.js';
+export type { QMDSearchResult };
+export interface QMDStatus {
+    indexHealth: string;
+    documentCount: number;
+    collections?: Array<{
+        name: string;
+        path: string;
+        documentCount: number;
+    }>;
+}
+export declare function isAvailable(): Promise<boolean>;
+export declare function search(query: string, options?: {
+    collection?: string;
+    limit?: number;
+    minScore?: number;
+}): Promise<QMDSearchResult[]>;
+export declare function vsearch(query: string, options?: {
+    collection?: string;
+    limit?: number;
+    minScore?: number;
+}): Promise<QMDSearchResult[]>;
+export declare function query(queryText: string, options?: {
+    collection?: string;
+    limit?: number;
+    minScore?: number;
+}): Promise<QMDSearchResult[]>;
+export declare function get(pathOrDocid: string, options?: {
+    full?: boolean;
+    maxBytes?: number;
+}): Promise<string>;
+export declare function status(): Promise<QMDStatus | null>;
+export declare function embed(): Promise<number[] | null>;
+export declare function ensureWikiDir(projectPath: string): Promise<string>;
+export declare function close(): Promise<void>;
+//# sourceMappingURL=qmd-wrapper.d.ts.map

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

@@ -0,0 +1,58 @@
+import { getQMDClient } from '../embeddings/qmd-client.js';
+export async function isAvailable() {
+    const client = await getQMDClient();
+    return client.isAvailable();
+}
+export async function search(query, options = {}) {
+    const client = await getQMDClient();
+    if (!(await client.isAvailable()))
+        return [];
+    return client.search({ query, ...options });
+}
+export async function vsearch(query, options = {}) {
+    const client = await getQMDClient();
+    if (!(await client.isAvailable()))
+        return [];
+    return client.vsearch({ query, ...options });
+}
+export async function query(queryText, options = {}) {
+    const client = await getQMDClient();
+    if (!(await client.isAvailable()))
+        return [];
+    return client.query({ query: queryText, ...options });
+}
+export async function get(pathOrDocid, options = {}) {
+    const client = await getQMDClient();
+    if (!(await client.isAvailable()))
+        return '';
+    return client.get({ pathOrDocid, ...options });
+}
+export async function status() {
+    const client = await getQMDClient();
+    if (!(await client.isAvailable()))
+        return null;
+    const result = await client.status();
+    if (!result)
+        return null;
+    return {
+        indexHealth: result.indexHealth,
+        documentCount: result.collections.reduce((sum, collection) => sum + collection.documentCount, 0),
+        collections: result.collections,
+    };
+}
+export async function embed() {
+    return null;
+}
+export async function ensureWikiDir(projectPath) {
+    const { join } = await import('path');
+    const { mkdirSync, existsSync } = await import('fs');
+    const wikiDir = join(projectPath, '.squish', 'wiki');
+    if (!existsSync(wikiDir))
+        mkdirSync(wikiDir, { recursive: true });
+    return wikiDir;
+}
+export async function close() {
+    const client = await getQMDClient();
+    await client.disconnect();
+}
+//# sourceMappingURL=qmd-wrapper.js.map

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,14 +1,14 @@
 /** 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);
-}
+import { estimateTokens } from '../context/context-window.js';
+import { getLatestProjectWorkingSetSummary } from './working-set.js';
+import { getHotCacheSummary } from '../hot-cache.js';
 export async function performAutoLoad(projectPath, customConfig) {
     const startTime = Date.now();
     const cfg = { ...DEFAULT_AUTO_LOAD_CONFIG, ...customConfig };
@@ -26,13 +26,38 @@ 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;
             return result;
         }
         const projectId = project.id;
+        try {
+            const workingSetSummary = await getLatestProjectWorkingSetSummary(projectPath);
+            if (workingSetSummary) {
+                result.tokensUsed += estimateTokens(workingSetSummary);
+            }
+        }
+        catch (error) {
+            const msg = error instanceof Error ? error.message : String(error);
+            result.warnings.push(`Failed to load session working set: ${msg}`);
+        }
+        // NEW: Load persistent hot cache (Karpathy-style, survives restart)
+        if (cfg.includeCoreMemory) {
+            try {
+                const hotCacheSummary = await getHotCacheSummary({ projectPath, maxEntries: 5 });
+                if (hotCacheSummary) {
+                    result.tokensUsed += estimateTokens(hotCacheSummary);
+                    logger.info('[AutoLoad] Hot cache loaded from persistent storage');
+                }
+            }
+            catch (error) {
+                const msg = error instanceof Error ? error.message : String(error);
+                result.warnings.push(`Failed to load hot cache: ${msg}`);
+                logger.warn(`[AutoLoad] Failed to load hot cache: ${msg}`);
+            }
+        }
         if (cfg.includeCoreMemory) {
             try {
                 await initializeCoreMemory(projectId);
@@ -52,7 +77,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/entity-tracker.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Session Entity Tracker
+ *
+ * Tracks "active" entities in conversation sessions to enable
+ * reference resolution (e.g., resolving "she" to "Alice").
+ */
+export interface SessionEntity {
+    entityId: string;
+    entityName: string;
+    entityType: string;
+    mentionCount: number;
+    lastMentionedAt: Date;
+    salience: number;
+}
+export interface SessionEntityMap {
+    sessionId: string;
+    entities: Map<string, SessionEntity>;
+    updatedAt: Date;
+}
+/**
+ * Track an entity mention in a session.
+ * Updates salience based on recency and frequency.
+ */
+export declare function trackEntityInSession(sessionId: string, entityId: string, entityName: string, entityType: string): void;
+/**
+ * Get active entities for a session, sorted by salience.
+ * Applies time-based decay to salience scores.
+ */
+export declare function getActiveSessionEntities(sessionId: string, options?: {
+    limit?: number;
+    minSalience?: number;
+    entityTypes?: string[];
+}): SessionEntity[];
+/**
+ * Resolve a reference (pronoun, definite reference) to an entity in the session.
+ * Returns the most salient entity matching the reference type.
+ */
+export declare function resolveReference(sessionId: string, reference: string): SessionEntity | null;
+/**
+ * Clear session entities (e.g., when a session ends).
+ */
+export declare function clearSessionEntities(sessionId: string): void;
+/**
+ * Get all active sessions.
+ */
+export declare function getActiveSessions(): string[];
+/**
+ * Decay all session entities (call periodically).
+ * Reduces salience of all entities across all sessions.
+ */
+export declare function decayAllSessionEntities(): void;
+/**
+ * Persist session entities to the database for durability.
+ * Called periodically or on session end.
+ */
+export declare function persistSessionEntities(sessionId: string): Promise<void>;
+/**
+ * Load session entities from the database.
+ * Called when a session starts.
+ */
+export declare function loadSessionEntities(sessionId: string): Promise<void>;
+//# sourceMappingURL=entity-tracker.d.ts.map