squish-memory 1.1.5 → 1.2.1

package/dist/core/layers/generator.js

@@ -1,76 +0,0 @@
-/** Layer Extractor - Creates L0/L1 truncated layers for token-efficient hierarchical retrieval */
-const DEFAULT_CONFIG = {
-    l0MaxLength: 50,
-    l1MaxLength: 300,
-    autoGenerate: true,
-};
-/**
- * Extract L0/L1/L2 layers for content via truncation
- */
-export async function extractLayers(content, config = {}) {
-    const l0MaxLength = config.l0MaxLength ?? DEFAULT_CONFIG.l0MaxLength;
-    const l1MaxLength = config.l1MaxLength ?? DEFAULT_CONFIG.l1MaxLength;
-    // Extract L0 and L1 in parallel
-    const [l0, l1] = await Promise.all([
-        extractL0Truncation(content, l0MaxLength),
-        extractL1Truncation(content, l1MaxLength),
-    ]);
-    const l2Tokens = countTokens(content);
-    const l0Tokens = countTokens(l0 || '');
-    const l1Tokens = countTokens(l1 || '');
-    return {
-        l0: l0 ?? '',
-        l1: l1 ?? '',
-        l2: content,
-        tokenCounts: {
-            l0: l0Tokens,
-            l1: l1Tokens,
-            l2: l2Tokens,
-        },
-    };
-}
-/**
- * Extract L0: Ultra-short truncated preview (first sentence or chars)
- */
-async function extractL0Truncation(content, maxLength) {
-    // Simple truncation for L0 (first sentence or chars)
-    const trimmed = content.trim();
-    const sentences = trimmed.split(/[.!?]/).filter(s => s.trim().length > 0);
-    // Take first non-empty sentence and truncate if needed
-    let result = sentences.length > 0 ? sentences[0] : trimmed.substring(0, maxLength);
-    if (result.length > maxLength) {
-        result = result.substring(0, maxLength - 3) + '...';
-    }
-    return result.trim();
-}
-/**
- * Extract L1: Short truncated preview (first 2 meaningful sentences)
- */
-async function extractL1Truncation(content, maxLength) {
-    // Simple truncation for L1 (first 2 meaningful sentences)
-    const trimmed = content.trim();
-    const sentences = trimmed.split(/[.!?]/).filter(s => s.trim().length > 10);
-    // Take first meaningful sentences and truncate if needed
-    let result = sentences.length > 0
-        ? sentences.slice(0, 2).join(' ').trim()
-        : trimmed.substring(0, maxLength);
-    if (result.length > maxLength) {
-        result = result.substring(0, maxLength - 3) + '...';
-    }
-    return result.trim();
-}
-/**
- * Count tokens (approximate, 4 chars = 1 token for English)
- */
-function countTokens(text) {
-    // Simple approximation: 4 chars per token
-    return Math.ceil(text.length / 4);
-}
-/**
- * Check if content should have layers auto-extracted
- */
-export function shouldAutoGenerate(contentLength) {
-    const threshold = 500;
-    return contentLength > threshold;
-}
-//# sourceMappingURL=generator.js.map

package/dist/core/lib/db-client.js

@@ -1,130 +0,0 @@
-/**
- * Database Client & Schema Loading Abstraction
- *
- * Provides a unified interface for accessing both the database client and schema
- * in a single call, eliminating repetitive patterns of:
- *   `const db = createDatabaseClient(await getDb()); const schema = await getSchema();`
- *
- * Features:
- * - Single async call to get both db and schema
- * - Consistent error handling with clear messages
- * - Preserves schema caching
- * - Provides raw connection for special cases
- * - Helper `withDbClient` for functional programming patterns
- *
- * @example
- * ```typescript
- * // Old pattern (repetitive)
- * const db = createDatabaseClient(await getDb());
- * const schema = await getSchema();
- *
- * // New pattern (unified)
- * const { db, schema } = await getDbClient();
- *
- * // With helper
- * const result = await withDbClient(async (client) => {
- *   return await client.db.select().from(client.schema.memories);
- * });
- * ```
- */
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../storage/database.js';
-/**
- * Internal cached schema to preserve getSchema() caching behavior
- */
-let cachedSchema = null;
-/**
- * Get a unified database client with both db and schema.
- *
- * This function:
- * 1. Calls getDb() to initialize/retrieve the database connection
- * 2. Calls getSchema() to get the appropriate schema (with caching)
- * 3. Wraps the db with createDatabaseClient() for unified API
- * 4. Returns all three as a single DbClient object
- *
- * Error handling:
- * - Wraps any database initialization errors with a clear message
- * - Preserves the original error as `cause` property
- *
- * Schema caching:
- * - Uses the same caching mechanism as getSchema()
- * - Multiple calls to getDbClient() will return the same schema reference
- *
- * @returns Promise<DbClient> Unified client with db, schema, and raw
- * @throws {Error} When database initialization fails, with cause attached
- *
- * @example
- * ```typescript
- * const { db, schema, raw } = await getDbClient();
- *
- * // Use db for queries
- * const memories = await db.select().from(schema.memories).limit(10);
- *
- * // Use raw for special cases
- * const client = (raw as any).$client;
- * if (client && typeof client.exec === 'function') {
- *   client.exec('VACUUM');
- * }
- * ```
- */
-export async function getDbClient() {
-    try {
-        // Get raw database connection
-        const rawDb = await getDb();
-        // Get schema (with caching)
-        if (!cachedSchema) {
-            cachedSchema = await getSchema();
-        }
-        // Create wrapped database client
-        const db = createDatabaseClient(rawDb);
-        return {
-            db,
-            schema: cachedSchema,
-            raw: rawDb,
-        };
-    }
-    catch (error) {
-        const message = error instanceof Error
-            ? `Database initialization failed: ${error.message}`
-            : 'Database initialization failed';
-        // Wrap error with clear message while preserving cause
-        const wrappedError = new Error(message);
-        // @ts-ignore - TypeScript doesn't allow 'cause' on Error, but it's valid
-        wrappedError.cause = error;
-        throw wrappedError;
-    }
-}
-/**
- * Execute an operation with a unified database client.
- *
- * Convenience wrapper that:
- * 1. Calls getDbClient() to obtain client
- * 2. Executes the provided operation
- * 3. Ensures proper cleanup if needed (no-op currently, for future extension)
- *
- * @param operation - Async function that receives the DbClient and returns a result
- * @returns Promise<T> The result returned by the operation
- * @throws {Error} When database initialization or operation fails
- *
- * @example
- * ```typescript
- * const count = await withDbClient(async (client) => {
- *   const result = await client.db
- *     .select({ count: sql`count(*)` })
- *     .from(client.schema.memories);
- *   return result[0].count;
- * });
- * ```
- */
-export async function withDbClient(operation) {
-    const client = await getDbClient();
-    try {
-        return await operation(client);
-    }
-    finally {
-        // Future: Add cleanup logic if needed (connection pooling, etc.)
-        // Currently getDb() handles connection pooling and reuse
-    }
-}
-//# sourceMappingURL=db-client.js.map

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

@@ -1,129 +0,0 @@
-/**
- * Shared Zod schemas for input validation across Squish
- * Provides consistent validation for common input types
- */
-import { z } from 'zod';
-/**
- * Limit schema: integer between 1 and 100, default 20
- */
-export declare const limitSchema: z.ZodDefault<z.ZodNumber>;
-/**
- * Offset schema: integer >= 0, default 0
- */
-export declare const offsetSchema: z.ZodDefault<z.ZodNumber>;
-/**
- * Project ID/path schema: non-empty string
- */
-export declare const projectIdSchema: z.ZodString;
-/**
- * Memory ID schema: valid UUID
- */
-export declare const memoryIdSchema: z.ZodString;
-/**
- * Pagination schema combining limit and offset
- */
-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;
-}>;
-/**
- * Search query schema: non-empty string
- */
-export declare const searchQuerySchema: z.ZodString;
-/**
- * Memory type schema
- */
-export declare const memoryTypeSchema: z.ZodEnum<["observation", "fact", "decision", "context", "preference", "note"]>;
-/**
- * Association type schema
- */
-export declare const associationTypeSchema: z.ZodEnum<["relates_to", "supports", "contradicts", "supersedes", "duplicate"]>;
-/**
- * Weight schema: number between 0 and 1
- */
-export declare const weightSchema: z.ZodNumber;
-/**
- * Learning type schema
- */
-export declare const learningTypeSchema: z.ZodEnum<["success", "failure", "fix", "observation"]>;
-/**
- * Observation type schema
- */
-export declare const observationTypeSchema: z.ZodEnum<["tool_use", "file_change", "error", "pattern", "insight"]>;
-/**
- * Confidence level schema
- */
-export declare const confidenceLevelSchema: z.ZodEnum<["certain", "speculative", "outdated"]>;
-/**
- * Search input schema (common for search operations)
- */
-export declare const searchInputSchema: z.ZodObject<{
-    query: z.ZodString;
-    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;
-}>;
-/**
- * Memory recall schema
- */
-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;
-}>;
-/**
- * Tag operation schema
- */
-export declare const tagOperationSchema: z.ZodObject<{
-    action: z.ZodEnum<["add", "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"]>>;
-    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;
-}>;
-//# sourceMappingURL=schemas.d.ts.map

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

@@ -1,14 +0,0 @@
-/**
- * Shared utility functions for the squish codebase
- */
-export declare function normalizeTimestamp(value: any): string | null;
-export declare function now(): string;
-export declare function isDatabaseUnavailableError(error: any): boolean;
-export declare function withDatabaseErrorHandling<T>(operation: () => Promise<T>, errorMessage: string): Promise<T>;
-export declare function clampLimit(value: number | undefined, defaultValue: number, min?: number, max?: number): number;
-export declare function prepareEmbedding(embedding: number[] | null): {
-    embedding?: number[] | null;
-    embeddingJson?: string | null;
-};
-export declare function determineOverallStatus(dbStatus: string, redisOk: boolean): string;
-//# sourceMappingURL=utils.d.ts.map

package/dist/core/lib/utils.js

@@ -1,90 +0,0 @@
-/**
- * Shared utility functions for the squish codebase
- */
-import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
-import { config } from '../../config.js';
-import { toSqliteJson } from '../memory/serialization.js';
-export function normalizeTimestamp(value) {
-    if (!value)
-        return null;
-    if (value instanceof Date)
-        return value.toISOString();
-    if (typeof value === 'number') {
-        try {
-            // Handle different timestamp formats using magnitude thresholds
-            // Microseconds: > 100000000000000 (e.g., 1700000000000000)
-            // Milliseconds: > 1000000000000 (e.g., 1700000000000)
-            // Seconds: <= 1000000000000 (e.g., 1700000000)
-            if (value > 100000000000000) {
-                return new Date(value / 1000).toISOString();
-            }
-            else if (value > 1000000000000) {
-                return new Date(value).toISOString();
-            }
-            else if (value >= 0) {
-                return new Date(value * 1000).toISOString();
-            }
-            return null;
-        }
-        catch {
-            return null;
-        }
-    }
-    if (typeof value === 'string') {
-        try {
-            const parsed = new Date(value);
-            if (!isNaN(parsed.getTime()))
-                return parsed.toISOString();
-            return null;
-        }
-        catch {
-            return null;
-        }
-    }
-    return null;
-}
-export function now() {
-    return new Date().toISOString();
-}
-export function isDatabaseUnavailableError(error) {
-    const message = error?.message || '';
-    return [
-        'Database unavailable',
-        'not a valid Win32 application',
-        'invalid ELF header',
-        'bun:',
-        'sql.js wasm asset not found',
-        'SQLite database initialization failed',
-        'working local SQLite driver',
-    ].some((pattern) => message.includes(pattern));
-}
-export async function withDatabaseErrorHandling(operation, errorMessage) {
-    try {
-        return await operation();
-    }
-    catch (dbError) {
-        if (isDatabaseUnavailableError(dbError)) {
-            throw new McpError(ErrorCode.InternalError, errorMessage);
-        }
-        throw dbError;
-    }
-}
-export function clampLimit(value, defaultValue, min = 1, max = 100) {
-    return Math.min(Math.max(value ?? defaultValue, min), max);
-}
-export function prepareEmbedding(embedding) {
-    if (config.isTeamMode) {
-        return { embedding: embedding ?? null };
-    }
-    return { embeddingJson: toSqliteJson(embedding ?? null) };
-}
-export function determineOverallStatus(dbStatus, redisOk) {
-    if ((dbStatus === 'ok' || dbStatus === 'unavailable') && redisOk) {
-        return 'ok';
-    }
-    if (dbStatus === 'unavailable') {
-        return 'degraded';
-    }
-    return 'error';
-}
-//# sourceMappingURL=utils.js.map

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

@@ -1,38 +0,0 @@
-/**
- * Input validation utilities for Squish
- * Consolidates scattered validation patterns into a unified module
- */
-import { normalizeTags } from '../memory/serialization.js';
-/**
- * Validate and normalize a limit value with bounds checking
- */
-export declare function validateLimit(value: number | string | undefined, defaultValue?: number, min?: number, max?: number): number;
-/**
- * Parse an integer with bounds checking
- */
-export declare function parseIntBounded(value: number | string | undefined, defaultValue: number, min: number, max: number): number;
-/**
- * Validate a project path
- */
-export declare function validateProjectPath(path: string | undefined, options?: {
-    createIfMissing?: boolean;
-    require?: boolean;
-}): Promise<string>;
-/**
- * Validate a UUID
- */
-export declare function validateUuid(id: string): boolean;
-/**
- * Require a valid UUID, throws if invalid
- */
-export declare function requireUuid(id: string): string;
-/**
- * Validate a date value
- *
- * @param value - The date to validate (string, Date, number, or undefined)
- * @returns Date object if valid, null otherwise
- */
-export declare function validateDate(value: string | Date | number | undefined): Date | null;
-export { normalizeTags };
-export { clampLimit } from './utils.js';
-//# sourceMappingURL=validation.d.ts.map

package/dist/core/lib/validation.js

@@ -1,151 +0,0 @@
-/**
- * Input validation utilities for Squish
- * Consolidates scattered validation patterns into a unified module
- */
-import { normalizeTags } from '../memory/serialization.js';
-/**
- * Validate and normalize a limit value with bounds checking
- */
-export function validateLimit(value, defaultValue = 20, min = 1, max = 100) {
-    // Handle undefined, null, empty string
-    if (value === undefined || value === null || value === '') {
-        return defaultValue;
-    }
-    // Convert string to number, truncate decimals
-    let num;
-    if (typeof value === 'string') {
-        const parsed = parseInt(value, 10);
-        if (isNaN(parsed)) {
-            return NaN;
-        }
-        num = parsed;
-    }
-    else {
-        // Truncate decimals for numbers
-        num = Math.trunc(value);
-    }
-    // Handle NaN
-    if (isNaN(num)) {
-        return NaN;
-    }
-    // Clamp to bounds
-    return Math.min(Math.max(num, min), max);
-}
-/**
- * Parse an integer with bounds checking
- */
-export function parseIntBounded(value, defaultValue, min, max) {
-    return validateLimit(value, defaultValue, min, max);
-}
-/**
- * Validate a project path
- */
-export async function validateProjectPath(path, options) {
-    const { createIfMissing = false, require: requireProject = false } = options || {};
-    // If path is undefined, throw if required or return current directory
-    if (path === undefined || path === '') {
-        if (requireProject) {
-            throw new Error('Project path is required');
-        }
-        return process.cwd();
-    }
-    // Resolve to absolute path
-    const absolutePath = path.startsWith('/') || /^[a-zA-Z]:\\/.test(path)
-        ? path
-        : path.startsWith('~')
-            ? path.replace(/^~/, process.env.HOME || process.env.USERPROFILE || '')
-            : path.startsWith('.')
-                ? path
-                : path;
-    // Check if project exists in database
-    const { getProjectByPath } = await import('../projects.js');
-    const existingProject = await getProjectByPath(absolutePath);
-    if (existingProject) {
-        return absolutePath;
-    }
-    // Project doesn't exist
-    if (requireProject) {
-        throw new Error(`Project not found: ${absolutePath}`);
-    }
-    if (createIfMissing) {
-        const { ensureProject } = await import('../projects.js');
-        await ensureProject(absolutePath);
-        return absolutePath;
-    }
-    // Return the path even if it doesn't exist in database (for non-db validation)
-    return absolutePath;
-}
-/**
- * Validate a UUID
- */
-export function validateUuid(id) {
-    if (typeof id !== 'string' || !id) {
-        return false;
-    }
-    // UUID v4/v5 regex pattern (8-4-4-4-12 hex digits)
-    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-    return uuidRegex.test(id);
-}
-/**
- * Require a valid UUID, throws if invalid
- */
-export function requireUuid(id) {
-    if (!validateUuid(id)) {
-        throw new Error('Invalid UUID');
-    }
-    return id;
-}
-/**
- * Validate a date value
- *
- * @param value - The date to validate (string, Date, number, or undefined)
- * @returns Date object if valid, null otherwise
- */
-export function validateDate(value) {
-    if (!value) {
-        return null;
-    }
-    try {
-        let date;
-        if (value instanceof Date) {
-            date = value;
-        }
-        else if (typeof value === 'number') {
-            // Handle both milliseconds and seconds timestamps
-            if (value > 100000000000000) {
-                // Microseconds, convert to milliseconds
-                date = new Date(value / 1000);
-            }
-            else if (value > 1000000000000) {
-                // Milliseconds
-                date = new Date(value);
-            }
-            else if (value >= 0) {
-                // Seconds
-                date = new Date(value * 1000);
-            }
-            else {
-                return null;
-            }
-        }
-        else if (typeof value === 'string') {
-            date = new Date(value);
-        }
-        else {
-            return null;
-        }
-        // Check if date is valid
-        if (isNaN(date.getTime())) {
-            return null;
-        }
-        return date;
-    }
-    catch {
-        return null;
-    }
-}
-// Re-export normalizeTags for tag validation
-export { normalizeTags };
-// Re-export clampLimit for backward compatibility
-export { clampLimit } from './utils.js';
-//# sourceMappingURL=validation.js.map

package/dist/core/lifecycle.d.ts

@@ -1,26 +0,0 @@
-/**
- * Memory Lifecycle Management
- * Implements sector-based decay, tier classification, and eviction policies
- *
- * Decay Formula: newScore = importanceScore * (1 - decayRate/100)^days
- * - decayRate: per-memory integer (e.g., 30 = 30% decay per decay cycle)
- * - days: days since lastDecayAt
- * - Tier demotion occurs when score drops below decayThreshold
- * - Cold memories below threshold get status = 'expired'
- */
-export interface LifecycleStats {
-    decayed: number;
-    evicted: number;
-    promoted: number;
-    tierChanges: {
-        hot: number;
-        warm: number;
-        cold: number;
-    };
-    expired: number;
-}
-/**
- * Run full lifecycle maintenance on all memories
- */
-export declare function runLifecycleMaintenance(projectId?: string): Promise<LifecycleStats>;
-//# sourceMappingURL=lifecycle.d.ts.map