squish-memory 1.1.5 → 1.2.0

package/dist/core/{obsidian-vault.js → integrations/obsidian-vault.js}

@@ -3,9 +3,10 @@
  * Appends hot memories to Obsidian daily notes
  * Format: YYYY-MM-DD.md with memory blocks
  */
-import { existsSync, mkdirSync, appendFileSync } from 'fs';
+import { existsSync, mkdirSync, appendFileSync, readFileSync, readdirSync } from 'fs';
 import { join } from 'path';
-import { logger } from './logger.js';
+import { randomUUID } from 'crypto';
+import { logger } from '../logger.js';
 /**
  * Append a memory to the daily note in Obsidian vault
  * Creates YYYY-MM-DD.md file if it doesn't exist
@@ -83,12 +84,73 @@ export function isObsidianConnected(vaultPath) {
     return existsSync(parentDir) || true; // Assume creatable if parent exists
 }
 /**
- * Read existing memories from Obsidian vault (for future import feature)
+ * Read existing memories from Obsidian vault (for import feature)
+ * Scans vault for .md files and extracts memory blocks
  */
 export async function readFromVault(vaultPath) {
-    // Future: Read .md files and parse memory blocks
-    // For MVP, this is placeholder
-    logger.info(`[Obsidian] readFromVault called for: ${vaultPath}`);
-    return [];
+    if (!existsSync(vaultPath)) {
+        logger.warn(`[Obsidian] Vault path does not exist: ${vaultPath}`);
+        return [];
+    }
+    const memories = [];
+    // Recursively find all .md files
+    const mdFiles = await findMarkdownFiles(vaultPath);
+    for (const filePath of mdFiles) {
+        try {
+            const content = readFileSync(filePath, 'utf-8');
+            const filename = filePath.split(/[/\\]/).pop() || '';
+            // Extract frontmatter if present
+            const frontmatterMatch = content.match(/^---\n([\s\S]*?)\n---/);
+            let tags = [];
+            if (frontmatterMatch) {
+                const tagMatch = frontmatterMatch[1].match(/tags:\s*\[([^\]]*)\]/);
+                if (tagMatch) {
+                    tags = tagMatch[1].split(',').map((t) => t.trim()).filter(Boolean);
+                }
+            }
+            // Extract content after frontmatter
+            const body = frontmatterMatch ? content.slice(frontmatterMatch[0].length).trim() : content;
+            // Skip empty files or very short ones
+            if (body.length < 10)
+                continue;
+            memories.push({
+                id: randomUUID(),
+                content: body,
+                tags,
+                type: 'observation'
+            });
+        }
+        catch (error) {
+            logger.warn(`[Obsidian] Failed to read file ${filePath}: ${error}`);
+        }
+    }
+    logger.info(`[Obsidian] Found ${memories.length} memories in vault`);
+    return memories;
+}
+/**
+ * Recursively find all markdown files in a directory
+ */
+async function findMarkdownFiles(dir) {
+    const files = [];
+    try {
+        const entries = readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = join(dir, entry.name);
+            if (entry.isDirectory()) {
+                // Skip hidden directories
+                if (!entry.name.startsWith('.')) {
+                    const subFiles = await findMarkdownFiles(fullPath);
+                    files.push(...subFiles);
+                }
+            }
+            else if (entry.isFile() && entry.name.endsWith('.md')) {
+                files.push(fullPath);
+            }
+        }
+    }
+    catch (error) {
+        logger.warn(`[Obsidian] Failed to read directory ${dir}: ${error}`);
+    }
+    return files;
 }
 //# sourceMappingURL=obsidian-vault.js.map

package/dist/core/lib/parse-embedding.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Parse embedding from various storage formats.
+ * Converted from 4 locations: hybrid-search.ts, consolidation.ts, memories.ts, entity-deduplicator.ts
+ *
+ * @param embeddingData - Input in Float32Array, Buffer, Uint8Array, JSON string, or Array format
+ * @returns Array of numbers or null if parsing fails
+ */
+export declare function parseEmbedding(embeddingData: unknown): number[] | null;
+//# sourceMappingURL=parse-embedding.d.ts.map

package/dist/core/lib/parse-embedding.js

@@ -0,0 +1,58 @@
+/**
+ * Parse embedding from various storage formats.
+ * Converted from 4 locations: hybrid-search.ts, consolidation.ts, memories.ts, entity-deduplicator.ts
+ *
+ * @param embeddingData - Input in Float32Array, Buffer, Uint8Array, JSON string, or Array format
+ * @returns Array of numbers or null if parsing fails
+ */
+export function parseEmbedding(embeddingData) {
+    if (!embeddingData)
+        return null;
+    // Handle Array directly (most common case)
+    if (Array.isArray(embeddingData)) {
+        return embeddingData;
+    }
+    // Handle Float32Array directly
+    if (embeddingData instanceof Float32Array) {
+        return Array.from(embeddingData);
+    }
+    // Handle Uint8Array and Buffer - try JSON first, then binary Float32
+    if (embeddingData instanceof Uint8Array || Buffer.isBuffer(embeddingData)) {
+        // Try to parse as JSON string first
+        try {
+            const json = JSON.parse(embeddingData.toString());
+            if (Array.isArray(json)) {
+                return json;
+            }
+        }
+        catch {
+            // Not JSON, try binary Float32
+        }
+        // Try to parse as binary Float32Array
+        try {
+            const buffer = embeddingData.buffer;
+            const arrayBuffer = buffer instanceof ArrayBuffer
+                ? buffer
+                : buffer;
+            const floatArray = new Float32Array(arrayBuffer);
+            return Array.from(floatArray);
+        }
+        catch {
+            return null;
+        }
+    }
+    // Handle JSON string
+    if (typeof embeddingData === 'string') {
+        try {
+            const parsed = JSON.parse(embeddingData);
+            if (Array.isArray(parsed)) {
+                return parsed;
+            }
+        }
+        catch {
+            return null;
+        }
+    }
+    return null;
+}
+//# sourceMappingURL=parse-embedding.js.map

package/dist/core/lib/schemas.d.ts

@@ -25,13 +25,7 @@ export declare const memoryIdSchema: z.ZodString;
 export declare const paginationSchema: z.ZodObject<{
     limit: z.ZodDefault<z.ZodNumber>;
     offset: z.ZodDefault<z.ZodNumber>;
-}, "strip", z.ZodTypeAny, {
-    limit: number;
-    offset: number;
-}, {
-    limit?: number | undefined;
-    offset?: number | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * Search query schema: non-empty string
  */
@@ -39,11 +33,24 @@ export declare const searchQuerySchema: z.ZodString;
 /**
  * Memory type schema
  */
-export declare const memoryTypeSchema: z.ZodEnum<["observation", "fact", "decision", "context", "preference", "note"]>;
+export declare const memoryTypeSchema: z.ZodEnum<{
+    observation: "observation";
+    fact: "fact";
+    decision: "decision";
+    context: "context";
+    preference: "preference";
+    note: "note";
+}>;
 /**
  * Association type schema
  */
-export declare const associationTypeSchema: z.ZodEnum<["relates_to", "supports", "contradicts", "supersedes", "duplicate"]>;
+export declare const associationTypeSchema: z.ZodEnum<{
+    supersedes: "supersedes";
+    contradicts: "contradicts";
+    supports: "supports";
+    relates_to: "relates_to";
+    duplicate: "duplicate";
+}>;
 /**
  * Weight schema: number between 0 and 1
  */
@@ -51,15 +58,30 @@ export declare const weightSchema: z.ZodNumber;
 /**
  * Learning type schema
  */
-export declare const learningTypeSchema: z.ZodEnum<["success", "failure", "fix", "observation"]>;
+export declare const learningTypeSchema: z.ZodEnum<{
+    observation: "observation";
+    success: "success";
+    failure: "failure";
+    fix: "fix";
+}>;
 /**
  * Observation type schema
  */
-export declare const observationTypeSchema: z.ZodEnum<["tool_use", "file_change", "error", "pattern", "insight"]>;
+export declare const observationTypeSchema: z.ZodEnum<{
+    error: "error";
+    insight: "insight";
+    pattern: "pattern";
+    tool_use: "tool_use";
+    file_change: "file_change";
+}>;
 /**
  * Confidence level schema
  */
-export declare const confidenceLevelSchema: z.ZodEnum<["certain", "speculative", "outdated"]>;
+export declare const confidenceLevelSchema: z.ZodEnum<{
+    certain: "certain";
+    speculative: "speculative";
+    outdated: "outdated";
+}>;
 /**
  * Search input schema (common for search operations)
  */
@@ -68,20 +90,15 @@ export declare const searchInputSchema: z.ZodObject<{
     limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
     offset: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
     project: z.ZodOptional<z.ZodString>;
-    type: z.ZodOptional<z.ZodEnum<["observation", "fact", "decision", "context", "preference", "note"]>>;
-}, "strip", z.ZodTypeAny, {
-    query: string;
-    project?: string | undefined;
-    type?: "observation" | "fact" | "decision" | "context" | "preference" | "note" | undefined;
-    limit?: number | undefined;
-    offset?: number | undefined;
-}, {
-    query: string;
-    project?: string | undefined;
-    type?: "observation" | "fact" | "decision" | "context" | "preference" | "note" | undefined;
-    limit?: number | undefined;
-    offset?: number | undefined;
-}>;
+    type: z.ZodOptional<z.ZodEnum<{
+        observation: "observation";
+        fact: "fact";
+        decision: "decision";
+        context: "context";
+        preference: "preference";
+        note: "note";
+    }>>;
+}, z.core.$strip>;
 /**
  * Memory recall schema
  */
@@ -89,41 +106,27 @@ export declare const recallInputSchema: z.ZodObject<{
     memoryId: z.ZodString;
     limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
     project: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    memoryId: string;
-    project?: string | undefined;
-    limit?: number | undefined;
-}, {
-    memoryId: string;
-    project?: string | undefined;
-    limit?: number | undefined;
-}>;
+}, z.core.$strip>;
 /**
  * Tag operation schema
  */
 export declare const tagOperationSchema: z.ZodObject<{
-    action: z.ZodEnum<["add", "remove"]>;
+    action: z.ZodEnum<{
+        add: "add";
+        remove: "remove";
+    }>;
     tag: z.ZodString;
     search: z.ZodOptional<z.ZodString>;
     olderThan: z.ZodOptional<z.ZodString>;
-    type: z.ZodOptional<z.ZodEnum<["observation", "fact", "decision", "context", "preference", "note"]>>;
+    type: z.ZodOptional<z.ZodEnum<{
+        observation: "observation";
+        fact: "fact";
+        decision: "decision";
+        context: "context";
+        preference: "preference";
+        note: "note";
+    }>>;
     limit: z.ZodOptional<z.ZodDefault<z.ZodNumber>>;
     project: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    action: "add" | "remove";
-    tag: string;
-    search?: string | undefined;
-    project?: string | undefined;
-    type?: "observation" | "fact" | "decision" | "context" | "preference" | "note" | undefined;
-    limit?: number | undefined;
-    olderThan?: string | undefined;
-}, {
-    action: "add" | "remove";
-    tag: string;
-    search?: string | undefined;
-    project?: string | undefined;
-    type?: "observation" | "fact" | "decision" | "context" | "preference" | "note" | undefined;
-    limit?: number | undefined;
-    olderThan?: string | undefined;
-}>;
+}, z.core.$strip>;
 //# sourceMappingURL=schemas.d.ts.map

package/dist/core/lib/types.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Shared type definitions for Squish Memory system
+ * Consolidated from core/memory/memories.ts and core/memory/normalization.ts
+ */
+export type MemoryType = 'observation' | 'fact' | 'decision' | 'context' | 'preference' | 'note' | 'task';
+/**
+ * Confidence level for memory records
+ * - certain: High confidence, verified information
+ * - speculative: Low confidence, unverified or uncertain
+ * - outdated: Information that may no longer be accurate
+ */
+export type ConfidenceLevel = 'certain' | 'speculative' | 'outdated';
+/**
+ * Unified MemoryRecord interface
+ * Used across memories.ts and normalization.ts
+ *
+ * Note: type is string to avoid circular dependency with memories.ts
+ * Use MemoryType for type checking when needed
+ */
+export interface MemoryRecord {
+    id: string;
+    projectId?: string | null;
+    type: string;
+    content: string;
+    summary?: string | null;
+    tags: string[];
+    metadata?: Record<string, unknown> | null;
+    createdAt?: string | null;
+    validFrom?: string | null;
+    validTo?: string | null;
+    recordedAt?: string | null;
+    similarity?: number;
+    importance?: number;
+    confidenceLevel?: ConfidenceLevel | null;
+}
+/**
+ * Result of a safety check
+ * Used to determine if a merge action can proceed
+ */
+export interface SafetyCheckResult {
+    passed: boolean;
+    warnings: string[];
+    blockers: string[];
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/core/lib/types.js

@@ -0,0 +1,6 @@
+/**
+ * Shared type definitions for Squish Memory system
+ * Consolidated from core/memory/memories.ts and core/memory/normalization.ts
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/core/lib/utils.d.ts

@@ -11,4 +11,8 @@ export declare function prepareEmbedding(embedding: number[] | null): {
     embeddingJson?: string | null;
 };
 export declare function determineOverallStatus(dbStatus: string, redisOk: boolean): string;
+export declare function parseDate(input: string): Date | null;
+export declare function filterByDateRange<T extends {
+    createdAt?: string | null;
+}>(items: T[], since?: string, until?: string): T[];
 //# sourceMappingURL=utils.d.ts.map

package/dist/core/lib/utils.js

@@ -87,4 +87,59 @@ export function determineOverallStatus(dbStatus, redisOk) {
     }
     return 'error';
 }
+// Date parsing utilities - shared between CLI and MCP
+// ============================================================================
+export function parseDate(input) {
+    if (!input)
+        return null;
+    const now = new Date();
+    const lower = input.toLowerCase().trim();
+    // Direct date parse
+    const parsed = new Date(input);
+    if (!isNaN(parsed.getTime()))
+        return parsed;
+    // Relative parsing
+    const dayMatch = lower.match(/(\d+)\s*day/i);
+    const weekMatch = lower.match(/(\d+)\s*week/i);
+    const monthMatch = lower.match(/(\d+)\s*month/i);
+    if (lower === 'today') {
+        const d = new Date(now);
+        d.setHours(0, 0, 0, 0);
+        return d;
+    }
+    if (lower === 'yesterday')
+        return new Date(now.getTime() - 86400000);
+    if (lower === 'thisweek' || lower === 'this week') {
+        const d = new Date(now);
+        d.setDate(d.getDate() - d.getDay());
+        d.setHours(0, 0, 0, 0);
+        return d;
+    }
+    if (lower === 'lastweek' || lower === 'last week') {
+        const d = new Date(now);
+        d.setDate(d.getDate() - d.getDay() - 7);
+        return d;
+    }
+    if (dayMatch)
+        return new Date(now.getTime() - parseInt(dayMatch[1]) * 86400000);
+    if (weekMatch)
+        return new Date(now.getTime() - parseInt(weekMatch[1]) * 604800000);
+    if (monthMatch)
+        return new Date(now.getTime() - parseInt(monthMatch[1]) * 2592000000);
+    return null;
+}
+export function filterByDateRange(items, since, until) {
+    const sinceDate = parseDate(since || '');
+    const untilDate = parseDate(until || '');
+    return items.filter(item => {
+        if (!item.createdAt)
+            return true;
+        const created = new Date(item.createdAt);
+        if (sinceDate && created < sinceDate)
+            return false;
+        if (untilDate && created > untilDate)
+            return false;
+        return true;
+    });
+}
 //# sourceMappingURL=utils.js.map

package/dist/core/lifecycle.d.ts

@@ -14,7 +14,6 @@ export interface LifecycleStats {
     promoted: number;
     tierChanges: {
         hot: number;
-        warm: number;
         cold: number;
     };
     expired: number;

package/dist/core/lifecycle.js

@@ -17,13 +17,14 @@ import { triggerTierChange, triggerDecayApplied } from './memory/hooks.js';
 /**
  * Default decay intervals by sector (days until decay check)
  * These determine how often memories in each sector are evaluated for decay
+ * Can be configured via config.sectorDecayIntervals
  */
 const SECTOR_DECAY_INTERVAL_DAYS = {
-    episodic: 30,
-    semantic: 90,
-    procedural: 180,
-    autobiographical: 365,
-    working: 7,
+    episodic: config.sectorDecayIntervals?.episodic || 30,
+    semantic: config.sectorDecayIntervals?.semantic || 90,
+    procedural: config.sectorDecayIntervals?.procedural || 180,
+    autobiographical: config.sectorDecayIntervals?.autobiographical || 365,
+    working: config.sectorDecayIntervals?.working || 7,
 };
 /**
  * Default decay rates by memory type (percentage per decay cycle)
@@ -40,7 +41,6 @@ const DEFAULT_DECAY_RATES = {
 };
 const TIER_THRESHOLDS = {
     hot: { recency: 7, coactivation: 10, salience: 70 },
-    warm: { recency: 30, coactivation: 5, salience: 50 },
     cold: { recency: Infinity, coactivation: 0, salience: 0 },
 };
 /**
@@ -48,13 +48,13 @@ const TIER_THRESHOLDS = {
  */
 export async function runLifecycleMaintenance(projectId) {
     if (!config.lifecycleEnabled) {
-        return { decayed: 0, evicted: 0, promoted: 0, tierChanges: { hot: 0, warm: 0, cold: 0 }, expired: 0 };
+        return { decayed: 0, evicted: 0, promoted: 0, tierChanges: { hot: 0, cold: 0 }, expired: 0 };
     }
     const stats = {
         decayed: 0,
         evicted: 0,
         promoted: 0,
-        tierChanges: { hot: 0, warm: 0, cold: 0 },
+        tierChanges: { hot: 0, cold: 0 },
         expired: 0,
     };
     try {
@@ -187,9 +187,9 @@ async function updateTiers(projectId, stats) {
             .from(schema.memories)
             .where(where)
             .limit(10000); // Process larger batches now
-        // Calculate tiers in memory
+        // Calculate tiers in memory (simplified: hot or cold only)
         const tierAssignments = new Map();
-        const tierCounts = { hot: 0, warm: 0, cold: 0 };
+        const tierCounts = { hot: 0, cold: 0 };
         for (const memory of memories) {
             const recencyDays = (now.getTime() - new Date(memory.createdAt).getTime()) / (24 * 60 * 60 * 1000);
             const coactivation = memory.coactivationScore || 0;
@@ -200,11 +200,6 @@ async function updateTiers(projectId, stats) {
                 salience >= TIER_THRESHOLDS.hot.salience) {
                 newTier = 'hot';
             }
-            else if (recencyDays <= TIER_THRESHOLDS.warm.recency &&
-                coactivation >= TIER_THRESHOLDS.warm.coactivation &&
-                salience >= TIER_THRESHOLDS.warm.salience) {
-                newTier = 'warm';
-            }
             if (newTier !== memory.tier) {
                 tierAssignments.set(memory.id, newTier);
                 tierCounts[newTier]++;
@@ -216,9 +211,6 @@ async function updateTiers(projectId, stats) {
         const hotIds = Array.from(tierAssignments.entries())
             .filter(([_, tier]) => tier === 'hot')
             .map(([id]) => id);
-        const warmIds = Array.from(tierAssignments.entries())
-            .filter(([_, tier]) => tier === 'warm')
-            .map(([id]) => id);
         const coldIds = Array.from(tierAssignments.entries())
             .filter(([_, tier]) => tier === 'cold')
             .map(([id]) => id);
@@ -229,11 +221,11 @@ async function updateTiers(projectId, stats) {
                 .set({ tier: 'hot', updatedAt: now })
                 .where(inArray(schema.memories.id, hotIds));
         }
-        if (warmIds.length > 0) {
+        if (coldIds.length > 0) {
             await db
                 .update(schema.memories)
-                .set({ tier: 'warm', updatedAt: now })
-                .where(inArray(schema.memories.id, warmIds));
+                .set({ tier: 'cold', updatedAt: now })
+                .where(inArray(schema.memories.id, coldIds));
         }
         if (coldIds.length > 0) {
             await db
@@ -268,11 +260,9 @@ async function updateTiers(projectId, stats) {
         }
         // Update stats
         stats.tierChanges.hot = tierCounts.hot;
-        stats.tierChanges.warm = tierCounts.warm;
         stats.tierChanges.cold = tierCounts.cold;
         logger.debug('Tier updates complete', {
             hot: tierCounts.hot,
-            warm: tierCounts.warm,
             cold: tierCounts.cold,
         });
     }

package/dist/core/logger.d.ts

@@ -6,6 +6,7 @@ declare class Logger {
     private debugEnabled;
     constructor(prefix?: string);
     private format;
+    private isQuiet;
     info(message: string, context?: LogContext): void;
     warn(message: string, context?: LogContext): void;
     error(message: string, error?: Error | any, context?: LogContext): void;

package/dist/core/logger.js

@@ -1,8 +1,3 @@
-function isQuietMode() {
-    return process.env.SQUISH_QUIET !== 'false' &&
-        process.env.DEBUG !== 'true' &&
-        process.env.DEBUG !== '1';
-}
 class Logger {
     prefix;
     debugEnabled;
@@ -15,14 +10,25 @@ class Logger {
         const ctx = context ? ` ${JSON.stringify(context)}` : '';
         return `[${this.prefix}:${level}] ${message}${ctx}`;
     }
+    isQuiet() {
+        return process.env.SQUISH_QUIET === 'true' || process.env.SQUISH_QUIET === '1';
+    }
     info(message, context) {
-        if (!isQuietMode())
-            console.error(this.format('info', message, context));
+        if (this.isQuiet()) {
+            return;
+        }
+        console.error(this.format('info', message, context));
     }
     warn(message, context) {
+        if (this.isQuiet()) {
+            return;
+        }
         console.error(this.format('warn', message, context));
     }
     error(message, error, context) {
+        if (this.isQuiet()) {
+            return;
+        }
         const errorMsg = error instanceof Error ? error.message : error;
         const ctx = { ...context, error: errorMsg };
         console.error(this.format('error', message, ctx));
@@ -31,7 +37,7 @@ class Logger {
         }
     }
     debug(message, context) {
-        if (this.debugEnabled) {
+        if (this.debugEnabled && !this.isQuiet()) {
             console.error(this.format('debug', message, context));
         }
     }

package/dist/core/mcp/tools.d.ts

@@ -2,8 +2,6 @@ import { MCPToolDefinition } from './types.js';
 export declare const squishSearchTool: MCPToolDefinition;
 export declare const squishRememberTool: MCPToolDefinition;
 export declare const squishRecallTool: MCPToolDefinition;
-export declare const squishEmbedTool: MCPToolDefinition;
-export declare const squishQMDSearchTool: MCPToolDefinition;
 export declare const squishHealthTool: MCPToolDefinition;
 export declare function getAllSquishTools(): MCPToolDefinition[];
 //# sourceMappingURL=tools.d.ts.map