squish-memory 1.0.2 → 1.2.0

package/dist/core/associations.js

@@ -47,9 +47,44 @@ export async function createAssociation(fromMemoryId, toMemoryId, type, weight =
     }
 }
 /**
- * Track co-activation of multiple memories (they were used together)
- * OPTIMIZED: Uses bulk upsert instead of N² individual database operations
+ * Auto-link memories that share entities
+ * Called after storing a memory to link it to related memories
  */
+export async function autoLinkByEntities(newMemoryId, entityNames, projectId) {
+    if (entityNames.length === 0)
+        return 0;
+    try {
+        const db = await getDb();
+        const schema = await getSchema();
+        // Find existing memories that contain any of these entity names
+        // Use simple LIKE query for matching
+        const conditions = entityNames.slice(0, 5).map(name => sql `LOWER(m.content) LIKE ${'%' + name + '%'}`);
+        const existing = await db
+            .select({
+            id: schema.memories.id,
+            content: schema.memories.content
+        })
+            .from(schema.memories)
+            .where(and(eq(schema.memories.projectId, projectId), sql `(${conditions.join(' OR ')})`, sql `id != ${newMemoryId}`))
+            .limit(10);
+        // Create associations for matching memories
+        let linked = 0;
+        for (const mem of existing) {
+            try {
+                await createAssociation(newMemoryId, mem.id, 'relates_to', 0.5);
+                linked++;
+            }
+            catch (e) {
+                // Skip duplicates
+            }
+        }
+        return linked;
+    }
+    catch (error) {
+        logger.error('Error auto-linking by entities', error);
+        return 0;
+    }
+}
 export async function trackCoactivation(memoryIds) {
     if (memoryIds.length < 2)
         return;

package/dist/core/autosave.d.ts

@@ -0,0 +1,19 @@
+export declare function getDefaultAutosaveHook(): {
+    getMessageCount: () => number;
+    updateConfig: (opts?: {
+        enabled?: boolean;
+        messageCount?: number;
+        hooks?: string[];
+    }) => void;
+    getConfig: () => {
+        enabled: boolean;
+        messageCount: number;
+        hooks: string[];
+    };
+};
+export declare function createAutosaveConfig(): {
+    enabled: boolean;
+    messageCount: number;
+    hooks: string[];
+};
+//# sourceMappingURL=autosave.d.ts.map

package/dist/core/autosave.js

@@ -0,0 +1,16 @@
+// Autosave functionality placeholder
+export function getDefaultAutosaveHook() {
+    let config = { enabled: false, messageCount: 10, hooks: [] };
+    return {
+        getMessageCount: () => 0,
+        updateConfig: (opts) => {
+            if (opts)
+                Object.assign(config, opts);
+        },
+        getConfig: () => ({ ...config })
+    };
+}
+export function createAutosaveConfig() {
+    return { enabled: false, messageCount: 10, hooks: [] };
+}
+//# sourceMappingURL=autosave.js.map

package/dist/core/beliefs/decay.d.ts

@@ -0,0 +1,27 @@
+interface DecayStats {
+    decayed: number;
+    sourceCountUpdated: number;
+    errors: string[];
+}
+export declare function applyBeliefDecay(projectId?: string): Promise<DecayStats>;
+/**
+ * Get beliefs that need attention (low confidence, disputed, or stale)
+ */
+export declare function getProblemBeliefs(projectId: string, options?: {
+    minDaysSinceConfirmation?: number;
+    confidenceThreshold?: number;
+}): Promise<Array<{
+    id: string;
+    type: string;
+    statement: string;
+    confidence: number;
+    status: string;
+    lastConfirmedAt: Date | null;
+    issue: string;
+}>>;
+/**
+ * Reinforce a belief (increase confidence when re-referenced)
+ */
+export declare function reinforceBelief(beliefId: string, boostAmount?: number): Promise<boolean>;
+export {};
+//# sourceMappingURL=decay.d.ts.map

package/dist/core/beliefs/decay.js

@@ -0,0 +1,217 @@
+import { getDbClient } from '../lib/db-client.js';
+import { logger } from './logger.js';
+/**
+ * Belief Decay Engine
+ *
+ * Manages confidence decay for beliefs over time
+ * Formula: newConfidence = oldConfidence * (1 - decayRate/100)^(daysSinceLastConfirmation / halfLife)
+ * - Default 30 days half-life (belief confidence halves every 30 days without reinforcement)
+ * - Disputed beliefs decay faster
+ * - Beliefs with more sources decay slower
+ */
+const DEFAULT_BELIEF_HALF_LIFE = 30; // days
+const DISPUTE_DECAY_MULTIPLIER = 1.5; // disputes decay 1.5x faster
+const SOURCE_BOOST_THRESHOLD = 3; // 3+ sources = slower decay
+export async function applyBeliefDecay(projectId) {
+    const stats = { decayed: 0, sourceCountUpdated: 0, errors: [] };
+    try {
+        const { raw } = await getDbClient();
+        const sqlite = raw.$client;
+        const isPg = typeof raw.query === 'function';
+        if (!sqlite && !isPg) {
+            logger.warn('No database client available for belief decay');
+            return stats;
+        }
+        const now = Date.now();
+        if (isPg) {
+            // PostgreSQL version
+            const pg = raw;
+            // Get all active beliefs
+            const beliefResult = await pg.query(`SELECT id, confidence, belief_decay_rate, last_confirmed_at, status, source_count 
+         FROM beliefs WHERE project_id = $1 AND status = 'active'`, [projectId]);
+            for (const belief of beliefResult.rows) {
+                try {
+                    const lastConfirmed = belief.last_confirmed_at ? new Date(belief.last_confirmed_at).getTime() : new Date(belief.created_at).getTime();
+                    const daysSince = Math.max(0, (now - lastConfirmed) / (24 * 60 * 60 * 1000));
+                    // Get source count for this belief
+                    const sourceResult = await pg.query(`SELECT COUNT(*) as cnt FROM belief_memory_sources WHERE belief_id = $1`, [belief.id]);
+                    const sourceCount = parseInt(sourceResult.rows[0]?.cnt ?? 1);
+                    // Calculate decay rate (disputes decay faster)
+                    const baseDecayRate = belief.belief_decay_rate ?? DEFAULT_BELIEF_HALF_LIFE;
+                    const decayMultiplier = belief.status === 'disputed' ? DISPUTE_DECAY_MULTIPLIER : 1;
+                    const sourceMultiplier = sourceCount >= SOURCE_BOOST_THRESHOLD ? 0.8 : 1;
+                    const effectiveHalfLife = baseDecayRate * decayMultiplier * sourceMultiplier;
+                    // Apply exponential decay: confidence = initial * (0.5)^(days/halfLife)
+                    const newConfidence = Math.round(belief.confidence * Math.pow(0.5, daysSince / effectiveHalfLife));
+                    if (newConfidence < belief.confidence) {
+                        await pg.query(`UPDATE beliefs SET confidence = $1, updated_at = NOW() WHERE id = $2`, [newConfidence, belief.id]);
+                        stats.decayed++;
+                    }
+                    if (sourceCount !== belief.source_count) {
+                        await pg.query(`UPDATE beliefs SET source_count = $1 WHERE id = $2`, [sourceCount, belief.id]);
+                        stats.sourceCountUpdated++;
+                    }
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    stats.errors.push(`Belief ${belief.id}: ${msg}`);
+                }
+            }
+        }
+        else if (sqlite) {
+            // SQLite version
+            const beliefs = sqlite.prepare(`
+        SELECT id, confidence, belief_decay_rate, last_confirmed_at, status, source_count, created_at
+        FROM beliefs WHERE project_id = ? AND status = 'active'
+      `).all(projectId);
+            for (const belief of beliefs) {
+                try {
+                    const lastConfirmed = belief.last_confirmed_at
+                        ? belief.last_confirmed_at
+                        : belief.created_at;
+                    const daysSince = Math.max(0, (now - lastConfirmed) / (24 * 60 * 60 * 1000));
+                    // Get source count
+                    const sourceResult = sqlite.prepare(`SELECT COUNT(*) as cnt FROM belief_memory_sources WHERE belief_id = ?`).get(belief.id);
+                    const sourceCount = sourceResult?.cnt ?? 1;
+                    // Calculate decay rate
+                    const baseDecayRate = belief.belief_decay_rate ?? DEFAULT_BELIEF_HALF_LIFE;
+                    const decayMultiplier = belief.status === 'disputed' ? DISPUTE_DECAY_MULTIPLIER : 1;
+                    const sourceMultiplier = sourceCount >= SOURCE_BOOST_THRESHOLD ? 0.8 : 1;
+                    const effectiveHalfLife = baseDecayRate * decayMultiplier * sourceMultiplier;
+                    const newConfidence = Math.round(belief.confidence * Math.pow(0.5, daysSince / effectiveHalfLife));
+                    if (newConfidence < belief.confidence) {
+                        sqlite.prepare(`
+              UPDATE beliefs SET confidence = ?, updated_at = ?
+              WHERE id = ?
+            `).run(newConfidence, Math.floor(now / 1000), belief.id);
+                        stats.decayed++;
+                    }
+                    if (sourceCount !== belief.source_count) {
+                        sqlite.prepare(`
+              UPDATE beliefs SET source_count = ? WHERE id = ?
+            `).run(sourceCount, belief.id);
+                        stats.sourceCountUpdated++;
+                    }
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    stats.errors.push(`Belief ${belief.id}: ${msg}`);
+                }
+            }
+        }
+        logger.info('Belief decay applied', stats);
+    }
+    catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        logger.error('Belief decay failed', { error: msg });
+        stats.errors.push(msg);
+    }
+    return stats;
+}
+/**
+ * Get beliefs that need attention (low confidence, disputed, or stale)
+ */
+export async function getProblemBeliefs(projectId, options) {
+    const problems = [];
+    try {
+        const { raw } = await getDbClient();
+        const sqlite = raw.$client;
+        const isPg = typeof raw.query === 'function';
+        const minDays = options?.minDaysSinceConfirmation ?? 30;
+        const confThreshold = options?.confidenceThreshold ?? 20;
+        const now = Date.now();
+        if (isPg) {
+            const pg = raw;
+            const result = await pg.query(`SELECT id, belief_type, statement, confidence, status, last_confirmed_at, created_at
+         FROM beliefs WHERE project_id = $1`, [projectId]);
+            for (const belief of result.rows) {
+                const lastConfirmed = belief.last_confirmed_at ? new Date(belief.last_confirmed_at) : new Date(belief.created_at);
+                const daysSince = (now - lastConfirmed.getTime()) / (24 * 60 * 60 * 1000);
+                let issue = '';
+                if (belief.status === 'disputed')
+                    issue = 'disputed';
+                else if (belief.confidence < confThreshold)
+                    issue = `low confidence (${belief.confidence})`;
+                else if (daysSince > minDays)
+                    issue = `stale (${Math.round(daysSince)} days)`;
+                if (issue) {
+                    problems.push({
+                        id: belief.id,
+                        type: belief.belief_type,
+                        statement: belief.statement,
+                        confidence: belief.confidence,
+                        status: belief.status,
+                        lastConfirmedAt: belief.last_confirmed_at,
+                        issue,
+                    });
+                }
+            }
+        }
+        else if (sqlite) {
+            const beliefs = sqlite.prepare(`
+        SELECT id, belief_type, statement, confidence, status, last_confirmed_at, created_at
+        FROM beliefs WHERE project_id = ?
+      `).all(projectId);
+            for (const belief of beliefs) {
+                const lastConfirmed = belief.last_confirmed_at
+                    ? new Date(belief.last_confirmed_at * 1000)
+                    : new Date(belief.created_at * 1000);
+                const daysSince = (now - lastConfirmed.getTime()) / (24 * 60 * 60 * 1000);
+                let issue = '';
+                if (belief.status === 'disputed')
+                    issue = 'disputed';
+                else if (belief.confidence < confThreshold)
+                    issue = `low confidence (${belief.confidence})`;
+                else if (daysSince > minDays)
+                    issue = `stale (${Math.round(daysSince)} days)`;
+                if (issue) {
+                    problems.push({
+                        id: belief.id,
+                        type: belief.belief_type,
+                        statement: belief.statement,
+                        confidence: belief.confidence,
+                        status: belief.status,
+                        lastConfirmedAt: belief.last_confirmed_at ? new Date(belief.last_confirmed_at * 1000) : null,
+                        issue,
+                    });
+                }
+            }
+        }
+    }
+    catch (error) {
+        logger.error('Failed to get problem beliefs', error);
+    }
+    return problems;
+}
+/**
+ * Reinforce a belief (increase confidence when re-referenced)
+ */
+export async function reinforceBelief(beliefId, boostAmount = 5) {
+    try {
+        const { raw } = await getDbClient();
+        const isPg = typeof raw.query === 'function';
+        if (isPg) {
+            await raw.query(`UPDATE beliefs SET 
+          confidence = LEAST(100, confidence + $1),
+          last_confirmed_at = NOW(),
+          updated_at = NOW()
+         WHERE id = $2`, [boostAmount, beliefId]);
+        }
+        else {
+            const sqlite = raw.$client;
+            sqlite.prepare(`
+        UPDATE beliefs SET 
+          confidence = MIN(100, confidence + ?),
+          last_confirmed_at = ?,
+          updated_at = ?
+        WHERE id = ?
+      `).run(boostAmount, Math.floor(Date.now() / 1000), Math.floor(Date.now() / 1000), beliefId);
+        }
+        return true;
+    }
+    catch (error) {
+        logger.error('Failed to reinforce belief', { beliefId, error });
+        return false;
+    }
+}
+//# sourceMappingURL=decay.js.map

package/dist/core/beliefs/extractor.d.ts

@@ -0,0 +1,9 @@
+import type { MemoryType } from '../memory/memories.js';
+import type { ExtractedBelief } from './types.js';
+export declare function extractBeliefsFromMemory(input: {
+    memoryId: string;
+    content: string;
+    type: MemoryType | string;
+    metadata?: Record<string, unknown> | null;
+}): ExtractedBelief[];
+//# sourceMappingURL=extractor.d.ts.map

package/dist/core/beliefs/extractor.js

@@ -0,0 +1,113 @@
+function cleanStatement(input) {
+    return input
+        .replace(/^(decision:|constraint:|state change:|reject(?:ed)?:|failure:|preference:)\s*/i, '')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+function splitReason(text) {
+    const match = text.match(/^(.*?)(?:\s+because\s+|\s+due to\s+)(.+)$/i);
+    if (!match)
+        return { statement: cleanStatement(text) };
+    return {
+        statement: cleanStatement(match[1]),
+        reason: cleanStatement(match[2]),
+    };
+}
+function deriveConfidence(type, hasReason) {
+    const base = type === 'decision' ? 0.84 :
+        type === 'preference' ? 0.8 :
+            type === 'failure_cause' ? 0.82 :
+                type === 'constraint' ? 0.78 :
+                    type === 'state_change' ? 0.76 :
+                        0.74;
+    return hasReason ? Math.min(0.95, base + 0.05) : base;
+}
+export function extractBeliefsFromMemory(input) {
+    const text = input.content.trim();
+    const lowered = text.toLowerCase();
+    const beliefs = [];
+    const addBelief = (belief) => {
+        const cleanedStatement = cleanStatement(belief.statement);
+        if (!cleanedStatement || cleanedStatement.length < 8)
+            return;
+        beliefs.push({
+            ...belief,
+            statement: cleanedStatement,
+            confidence: belief.confidence ?? deriveConfidence(belief.type, Boolean(belief.reason)),
+            sourceMemoryIds: [input.memoryId],
+        });
+    };
+    if (input.type === 'decision' || /\b(decision:|decided to|we chose|going with|final decision)\b/i.test(text)) {
+        const { statement, reason } = splitReason(text);
+        addBelief({
+            type: 'decision',
+            statement,
+            reason,
+            status: 'active',
+            evidenceSummary: text,
+        });
+    }
+    if (input.type === 'preference' || /\b(prefers?|likes?|dislikes?|hates?)\b/i.test(text)) {
+        const { statement, reason } = splitReason(text);
+        addBelief({
+            type: 'preference',
+            statement,
+            reason,
+            status: 'active',
+            evidenceSummary: text,
+        });
+    }
+    const failureMatch = text.match(/\b(?:failed|failure|broke|error)\b.*?(?:because|due to)\s+(.+)/i);
+    if (failureMatch) {
+        addBelief({
+            type: 'failure_cause',
+            statement: cleanStatement(text.split(/(?:because|due to)/i)[0] ?? text),
+            reason: cleanStatement(failureMatch[1]),
+            status: 'active',
+            evidenceSummary: text,
+            edges: [{ type: 'causes', targetStatement: cleanStatement(failureMatch[1]) }],
+        });
+    }
+    if (/\b(constraint:|must not|cannot|can't|blocked by|required to|needs to)\b/i.test(text)) {
+        addBelief({
+            type: 'constraint',
+            statement: text,
+            status: 'active',
+            evidenceSummary: text,
+        });
+    }
+    const stateMatch = text.match(/\b(?:state changed from|changed from)\s+(.+?)\s+to\s+(.+?)(?:\s+after\s+(.+))?$/i);
+    if (stateMatch) {
+        addBelief({
+            type: 'state_change',
+            statement: `${cleanStatement(stateMatch[1])} -> ${cleanStatement(stateMatch[2])}`,
+            reason: stateMatch[3] ? cleanStatement(stateMatch[3]) : undefined,
+            status: 'active',
+            evidenceSummary: text,
+        });
+    }
+    const disputePatterns = [
+        /\b(reject|rejected|do not use|don't use|instead of)\b/i,
+        /\bbandaid\b/i,
+    ];
+    if (disputePatterns.some((pattern) => pattern.test(text))) {
+        const sentence = text.split(/[.!?]/).find((part) => /reject|bandaid|instead of|do not use|don't use/i.test(part)) ?? text;
+        addBelief({
+            type: 'dispute',
+            statement: sentence,
+            status: 'disputed',
+            evidenceSummary: text,
+        });
+    }
+    const deduped = new Map();
+    for (const belief of beliefs) {
+        const key = `${belief.type}:${belief.statement.toLowerCase()}`;
+        if (!deduped.has(key))
+            deduped.set(key, belief);
+    }
+    if (deduped.size === 0 && !/\b(because|due to|prefer|decision|constraint|changed from|reject)\b/.test(lowered)) {
+        return [];
+    }
+    return [...deduped.values()];
+}
+//# sourceMappingURL=extractor.js.map

package/dist/core/beliefs/store.d.ts

@@ -0,0 +1,46 @@
+import type { ExtractedBelief, StoredBelief } from './types.js';
+export declare function upsertBeliefsForMemory(input: {
+    projectId: string;
+    memoryId: string;
+    beliefs: ExtractedBelief[];
+}): Promise<StoredBelief[]>;
+export declare function getBeliefsForMemory(memoryId: string): Promise<StoredBelief[]>;
+/**
+ * Get all beliefs for a project
+ */
+export declare function getAllBeliefs(projectId: string, options?: {
+    type?: string;
+    status?: string;
+    minConfidence?: number;
+    limit?: number;
+}): Promise<StoredBelief[]>;
+/**
+ * Search beliefs by statement content
+ */
+export declare function searchBeliefs(projectId: string, query: string, options?: {
+    type?: string;
+    minConfidence?: number;
+    limit?: number;
+}): Promise<StoredBelief[]>;
+/**
+ * Get active constraint beliefs for session boot
+ * Returns beliefs that should shape next actions
+ */
+export declare function getActiveConstraints(projectId: string): Promise<StoredBelief[]>;
+/**
+ * Get active decision beliefs for session boot
+ * Returns decisions that should guide next actions
+ */
+export declare function getActiveDecisions(projectId: string): Promise<StoredBelief[]>;
+/**
+ * Get recent failure beliefs for session boot
+ * Returns failure_cause beliefs to avoid repeating mistakes
+ * @param count - Number of recent failures to return (default 10)
+ */
+export declare function getRecentFailures(projectId: string, count?: number): Promise<StoredBelief[]>;
+/**
+ * Get beliefs relevant to a task/query for session boot
+ * Used to inject relevant beliefs at session start
+ */
+export declare function getRelevantBeliefs(projectId: string, taskQuery: string, limit?: number): Promise<StoredBelief[]>;
+//# sourceMappingURL=store.d.ts.map