squish-memory 1.2.0 → 1.2.1

package/dist/core/embeddings/transformers-local.d.ts

@@ -1,64 +0,0 @@
-/**
- * Transformers.js Local Embedding Provider
- *
- * Uses ONNX-based transformer models for high-quality local embeddings.
- * Supports Hugging Face ONNX embedding models.
- *
- * Usage:
- *   Set SQUISH_EMBEDDINGS_PROVIDER=transformers
- *   Required: SQUISH_LOCAL_MODEL=<huggingface-onnx-model>
- *
- * Download models automatically on first use. Models cached in HuggingFace cache directory.
- */
-export interface TransformersLocalConfig {
-    model: string;
-    device: 'cpu' | 'webgpu';
-    dtype: 'q8' | 'q4' | 'f16' | 'f32';
-}
-/**
- * Check if pipeline is loaded
- */
-export declare function isReady(): boolean;
-/**
- * Get embedding dimension for current model
- */
-export declare function getEmbeddingDimension(): number;
-/**
- * Generate embedding for a single text input
- * Uses mean pooling + L2 normalization
- */
-export declare function getEmbedding(text: string): Promise<number[] | null>;
-/**
- * Generate embeddings for multiple texts in batch
- * Processes efficiently with batching
- */
-export declare function getBatchEmbeddings(texts: string[], batchSize?: number): Promise<Array<number[] | null>>;
-/**
- * Check health of the transformers provider
- */
-export declare function checkHealth(): Promise<{
-    available: boolean;
-    latencyMs?: number;
-    error?: string;
-    model?: string;
-    dimension?: number;
-}>;
-/**
- * Unload the pipeline (for testing or memory management)
- */
-export declare function unload(): Promise<void>;
-/**
- * Warm up the model with a test input
- */
-export declare function warmup(): Promise<boolean>;
-declare const _default: {
-    isReady: typeof isReady;
-    getEmbeddingDimension: typeof getEmbeddingDimension;
-    getEmbedding: typeof getEmbedding;
-    getBatchEmbeddings: typeof getBatchEmbeddings;
-    checkHealth: typeof checkHealth;
-    unload: typeof unload;
-    warmup: typeof warmup;
-};
-export default _default;
-//# sourceMappingURL=transformers-local.d.ts.map

package/dist/core/embeddings/transformers-local.js

@@ -1,213 +0,0 @@
-/**
- * Transformers.js Local Embedding Provider
- *
- * Uses ONNX-based transformer models for high-quality local embeddings.
- * Supports Hugging Face ONNX embedding models.
- *
- * Usage:
- *   Set SQUISH_EMBEDDINGS_PROVIDER=transformers
- *   Required: SQUISH_LOCAL_MODEL=<huggingface-onnx-model>
- *
- * Download models automatically on first use. Models cached in HuggingFace cache directory.
- */
-import { pipeline } from '@huggingface/transformers';
-import { logger } from '../logger.js';
-import { config } from '../../config.js';
-const DEFAULT_CONFIG = {
-    model: '',
-    device: 'cpu',
-    dtype: 'q8', // Quantized for smaller size + faster loading
-};
-// Singleton pipeline instance
-let embeddingPipeline = null;
-let isLoading = false;
-let loadPromise = null;
-/**
- * Get or initialize the embedding pipeline (lazy loading)
- */
-async function getPipeline() {
-    // Return existing pipeline
-    if (embeddingPipeline) {
-        return embeddingPipeline;
-    }
-    // Already loading - wait for it
-    if (isLoading && loadPromise) {
-        return loadPromise;
-    }
-    // Start loading
-    isLoading = true;
-    const model = config.transformersLocalModel;
-    if (!model) {
-        isLoading = false;
-        throw new Error('Transformers provider requires SQUISH_LOCAL_MODEL to be set');
-    }
-    logger.info(`Loading transformers local model: ${model}`);
-    loadPromise = (async () => {
-        try {
-            embeddingPipeline = await pipeline('feature-extraction', model, {
-                device: DEFAULT_CONFIG.device,
-                dtype: DEFAULT_CONFIG.dtype,
-            });
-            logger.info(`Transformers local model loaded: ${model}`);
-            return embeddingPipeline;
-        }
-        catch (error) {
-            logger.error(`Failed to load transformers model: ${error}`);
-            embeddingPipeline = null;
-            throw error;
-        }
-        finally {
-            isLoading = false;
-            loadPromise = null;
-        }
-    })();
-    return loadPromise;
-}
-/**
- * Check if pipeline is loaded
- */
-export function isReady() {
-    return embeddingPipeline !== null;
-}
-/**
- * Get embedding dimension for current model
- */
-export function getEmbeddingDimension() {
-    return 0;
-}
-/**
- * Generate embedding for a single text input
- * Uses mean pooling + L2 normalization
- */
-export async function getEmbedding(text) {
-    if (!text || typeof text !== 'string') {
-        return null;
-    }
-    try {
-        const pipeline = await getPipeline();
-        if (!pipeline) {
-            return null;
-        }
-        // Truncate to max sequence length (256 tokens)
-        const truncatedText = text.slice(0, 512);
-        // Run feature extraction with pooling
-        const output = await pipeline(truncatedText, {
-            pooling: 'mean',
-            normalize: true,
-        });
-        // Convert tensor to array
-        const embedding = Array.from(output.data);
-        return embedding;
-    }
-    catch (error) {
-        logger.warn(`Transformers embedding error: ${error}`);
-        return null;
-    }
-}
-/**
- * Generate embeddings for multiple texts in batch
- * Processes efficiently with batching
- */
-export async function getBatchEmbeddings(texts, batchSize = 8) {
-    if (texts.length === 0) {
-        return [];
-    }
-    const results = new Array(texts.length).fill(null);
-    // Process in batches
-    for (let i = 0; i < texts.length; i += batchSize) {
-        const batchEnd = Math.min(i + batchSize, texts.length);
-        const batch = texts.slice(i, batchEnd);
-        const indices = [...Array(batch.length).keys()].map(j => i + j);
-        try {
-            const pipeline = await getPipeline();
-            if (!pipeline) {
-                continue;
-            }
-            // Truncate each text
-            const truncatedBatch = batch.map(t => t.slice(0, 512));
-            // Process batch
-            const outputs = await Promise.all(truncatedBatch.map(text => pipeline(text, { pooling: 'mean', normalize: true })));
-            // Store results
-            for (let j = 0; j < outputs.length; j++) {
-                results[indices[j]] = Array.from(outputs[j].data);
-            }
-        }
-        catch (error) {
-            logger.warn(`Transformers batch embedding error: ${error}`);
-        }
-    }
-    return results;
-}
-/**
- * Check health of the transformers provider
- */
-export async function checkHealth() {
-    const model = config.transformersLocalModel;
-    if (!model) {
-        return {
-            available: false,
-            error: 'SQUISH_LOCAL_MODEL is not configured',
-        };
-    }
-    // Check if library is available
-    try {
-        await import('@huggingface/transformers');
-    }
-    catch (error) {
-        return {
-            available: false,
-            error: '@huggingface/transformers not installed',
-        };
-    }
-    // Try quick embedding
-    const start = Date.now();
-    try {
-        const embedding = await getEmbedding('health check test');
-        const latency = Date.now() - start;
-        return {
-            available: embedding !== null && embedding.length > 0,
-            latencyMs: latency,
-            model,
-            dimension: embedding?.length || 0,
-        };
-    }
-    catch (error) {
-        return {
-            available: false,
-            error: error.message,
-            model,
-        };
-    }
-}
-/**
- * Unload the pipeline (for testing or memory management)
- */
-export async function unload() {
-    if (embeddingPipeline) {
-        // Pipeline doesn't have explicit cleanup, just release reference
-        embeddingPipeline = null;
-        logger.info('Transformers pipeline unloaded');
-    }
-}
-/**
- * Warm up the model with a test input
- */
-export async function warmup() {
-    try {
-        const result = await getEmbedding('warmup test');
-        return result !== null && result.length > 0;
-    }
-    catch {
-        return false;
-    }
-}
-export default {
-    isReady,
-    getEmbeddingDimension,
-    getEmbedding,
-    getBatchEmbeddings,
-    checkHealth,
-    unload,
-    warmup,
-};
-//# sourceMappingURL=transformers-local.js.map

package/dist/core/embeddings.d.ts

@@ -1,2 +0,0 @@
-export * from './embeddings/embeddings';
-//# sourceMappingURL=embeddings.d.ts.map

package/dist/core/embeddings.js

@@ -1,3 +0,0 @@
-// Re-export from embeddings directory
-export * from './embeddings/embeddings';
-//# sourceMappingURL=embeddings.js.map

package/dist/core/error-handling.d.ts

@@ -1,63 +0,0 @@
-/**
- * Unified Error Handling System for Squish
- * Provides standardized error handling across CLI, Web API, MCP server, and algorithm handlers
- */
-import { isDatabaseUnavailableError } from './lib/utils.js';
-export { isDatabaseUnavailableError };
-/**
- * Wraps database operations with standardized error handling
- */
-export declare function withDbErrorHandling<T>(operation: () => Promise<T>, context: string): Promise<T>;
-/**
- * Formats errors for Web API responses
- */
-export declare function formatApiError(error: any, defaultStatus?: number): {
-    status: number;
-    response: {
-        status: string;
-        message: string;
-    };
-};
-/**
- * Formats errors for MCP tool responses
- */
-export declare function formatMcpError(error: any, context?: string): never;
-/**
- * Formats errors for CLI commands
- */
-export declare function formatCliError(error: any, exitCode?: number): never;
-/**
- * Formats errors for algorithm handlers
- */
-export declare function formatAlgorithmError(error: any, context?: string): {
-    ok: false;
-    error: string;
-};
-/**
- * Formats successful responses for algorithm handlers.
- *
- * @param data - The success data to return
- * @param message - Optional success message
- * @returns Object with ok: true, optional message, and data
- */
-export declare function formatAlgorithmSuccess<T>(data: T, message?: string): {
-    ok: true;
-    data: T;
-    message?: string;
-};
-/**
- * Error thrown when validation fails
- */
-export declare class ValidationError extends Error {
-    field?: string | undefined;
-    constructor(message: string, field?: string | undefined);
-}
-/**
- * Error thrown when a requested resource is not found.
- * Used for missing memories, projects, etc.
- */
-export declare class NotFoundError extends Error {
-    resource?: string | undefined;
-    constructor(message: string, resource?: string | undefined);
-}
-//# sourceMappingURL=error-handling.d.ts.map

package/dist/core/error-handling.js

@@ -1,173 +0,0 @@
-/**
- * Unified Error Handling System for Squish
- * Provides standardized error handling across CLI, Web API, MCP server, and algorithm handlers
- */
-import { ErrorCode, McpError } from '@modelcontextprotocol/sdk/types.js';
-import { isDatabaseUnavailableError } from './lib/utils.js';
-export { isDatabaseUnavailableError };
-// Database operation wrapper
-/**
- * Wraps database operations with standardized error handling
- */
-export async function withDbErrorHandling(operation, context) {
-    try {
-        return await operation();
-    }
-    catch (dbError) {
-        if (isDatabaseUnavailableError(dbError)) {
-            throw new Error(`Database unavailable: ${context}. Please check your database connection.`);
-        }
-        throw dbError;
-    }
-}
-// API Response Formatters
-/**
- * Formats errors for Web API responses
- */
-export function formatApiError(error, defaultStatus = 500) {
-    let message;
-    if (typeof error === 'string') {
-        message = error;
-    }
-    else if (error instanceof Error) {
-        message = error.message;
-    }
-    else if (error && typeof error === 'object' && 'message' in error) {
-        message = String(error.message);
-    }
-    else if (error && typeof error === 'object') {
-        message = 'Unknown error';
-    }
-    else {
-        message = 'Unknown error';
-    }
-    // Check if it's a database unavailable error
-    if (isDatabaseUnavailableError(error)) {
-        return {
-            status: 503,
-            response: {
-                status: 'error',
-                message: `Service unavailable: ${message}`
-            }
-        };
-    }
-    // Check for custom error classes with status hints
-    if (error.status) {
-        return {
-            status: error.status,
-            response: {
-                status: 'error',
-                message
-            }
-        };
-    }
-    return {
-        status: defaultStatus,
-        response: {
-            status: 'error',
-            message
-        }
-    };
-}
-// MCP Error Formatter
-/**
- * Formats errors for MCP tool responses
- */
-export function formatMcpError(error, context) {
-    const message = error?.message || error?.toString() || 'Unknown error';
-    const fullMessage = context ? `${context}: ${message}` : message;
-    // Determine appropriate error code
-    let code;
-    if (isDatabaseUnavailableError(error)) {
-        code = ErrorCode.InternalError; // -32603
-    }
-    else if (error instanceof ValidationError) {
-        code = ErrorCode.InvalidParams; // -32602
-    }
-    else {
-        code = ErrorCode.InternalError;
-    }
-    throw new McpError(code, fullMessage);
-}
-// CLI Error Formatter
-/**
- * Formats errors for CLI commands
- */
-export function formatCliError(error, exitCode = 1) {
-    let message;
-    if (typeof error === 'string') {
-        message = error;
-    }
-    else if (error instanceof Error) {
-        message = error.message;
-    }
-    else if (error && typeof error === 'object' && 'message' in error) {
-        message = String(error.message);
-    }
-    else {
-        message = 'Unknown error';
-    }
-    // Output JSON to stdout for CLI consumers
-    console.log(JSON.stringify({ ok: false, error: message }, null, 2));
-    process.exit(exitCode);
-}
-// Algorithm Handler Formatters
-/**
- * Formats errors for algorithm handlers
- */
-export function formatAlgorithmError(error, context) {
-    let message;
-    if (typeof error === 'string') {
-        message = error;
-    }
-    else if (error instanceof Error) {
-        message = error.message;
-    }
-    else if (error && typeof error === 'object' && 'message' in error) {
-        message = String(error.message);
-    }
-    else {
-        message = 'Unknown error';
-    }
-    const fullMessage = context ? `${context}: ${message}` : message;
-    return { ok: false, error: fullMessage };
-}
-/**
- * Formats successful responses for algorithm handlers.
- *
- * @param data - The success data to return
- * @param message - Optional success message
- * @returns Object with ok: true, optional message, and data
- */
-export function formatAlgorithmSuccess(data, message) {
-    const result = { ok: true, data };
-    if (message) {
-        result.message = message;
-    }
-    return result;
-}
-// Custom Error Classes
-/**
- * Error thrown when validation fails
- */
-export class ValidationError extends Error {
-    field;
-    constructor(message, field) {
-        super(message);
-        this.field = field;
-        this.name = 'ValidationError';
-    }
-}
-/**
- * Error thrown when a requested resource is not found.
- * Used for missing memories, projects, etc.
- */
-export class NotFoundError extends Error {
-    resource;
-    constructor(message, resource) {
-        super(message);
-        this.resource = resource;
-        this.name = 'NotFoundError';
-    }
-}
-//# sourceMappingURL=error-handling.js.map

package/dist/core/graph/entity-deduplicator.d.ts

@@ -1,24 +0,0 @@
-/**
- * Entity Deduplicator
- *
- * Deduplicates entities using embedding similarity and string matching.
- * Critical for knowledge graph - prevents duplicate nodes for aliases like "AWS" / "Amazon Web Services".
- */
-export interface DeduplicationResult {
-    merged: number;
-    aliases: Array<{
-        from: string;
-        to: string;
-        similarity: number;
-    }>;
-    totalEntities: number;
-    uniqueEntities: number;
-}
-/**
- * Find and merge duplicate entities in a project.
- */
-export declare function deduplicateProjectEntities(projectId: string, options?: {
-    similarityThreshold?: number;
-    dryRun?: boolean;
-}): Promise<DeduplicationResult>;
-//# sourceMappingURL=entity-deduplicator.d.ts.map