squish-memory 1.0.2 → 1.1.5

package/dist/core/context/context-window.js

@@ -0,0 +1,177 @@
+import { eq, sql } from 'drizzle-orm';
+import { getDb } from '../../db/index.js';
+import { getSchema } from '../../db/schema.js';
+import { createDatabaseClient } from '../storage/database.js';
+import { requireProject } from '../projects.js';
+export const DEFAULT_CONTEXT_CONFIG = {
+    maxTokens: 128000,
+    warningThreshold: 0.80,
+    criticalThreshold: 0.95,
+};
+export function estimateTokens(content) {
+    if (!content)
+        return 0;
+    return Math.ceil(content.length / 4);
+}
+export async function getTokenUsage(projectPath) {
+    const project = await requireProject(projectPath);
+    const projectId = project.id;
+    const db = createDatabaseClient(await getDb());
+    const schema = await getSchema();
+    const memories = schema.memories;
+    const coreMemory = schema.coreMemory;
+    const coreMemoryRows = await db
+        .select()
+        .from(coreMemory)
+        .where(eq(coreMemory.projectId, projectId));
+    let coreMemoryTokens = 0;
+    for (const row of coreMemoryRows) {
+        coreMemoryTokens += row.tokensEstimate || estimateTokens(row.content || '');
+    }
+    const memoryRows = await db
+        .select({
+        tokens: memories.tokensEstimate,
+        content: memories.content,
+    })
+        .from(memories)
+        .where(eq(memories.projectId, projectId));
+    let memoriesTokens = 0;
+    for (const row of memoryRows) {
+        memoriesTokens += row.tokens || estimateTokens(row.content || '');
+    }
+    const totalTokens = coreMemoryTokens + memoriesTokens;
+    const config = DEFAULT_CONTEXT_CONFIG;
+    const usagePercent = (totalTokens / config.maxTokens) * 100;
+    const remainingTokens = Math.max(0, config.maxTokens - totalTokens);
+    let status = 'ok';
+    if (usagePercent >= config.criticalThreshold * 100) {
+        status = 'critical';
+    }
+    else if (usagePercent >= config.warningThreshold * 100) {
+        status = 'warning';
+    }
+    return {
+        coreMemoryTokens,
+        memoriesTokens,
+        totalTokens,
+        maxTokens: config.maxTokens,
+        usagePercent,
+        status,
+        remainingTokens,
+    };
+}
+export async function checkContextLimit(projectPath, additionalTokens) {
+    const stats = await getTokenUsage(projectPath);
+    const projectedTotal = stats.totalTokens + additionalTokens;
+    const projectedPercent = (projectedTotal / stats.maxTokens) * 100;
+    if (projectedPercent >= DEFAULT_CONTEXT_CONFIG.criticalThreshold * 100) {
+        return {
+            ok: false,
+            warning: `CRITICAL: Adding ${additionalTokens} tokens would exceed ${(DEFAULT_CONTEXT_CONFIG.criticalThreshold * 100).toFixed(0)}% of context limit (${projectedPercent.toFixed(1)}% projected). Consider optimizing first.`,
+            stats,
+        };
+    }
+    if (projectedPercent >= DEFAULT_CONTEXT_CONFIG.warningThreshold * 100) {
+        return {
+            ok: true,
+            warning: `WARNING: Adding ${additionalTokens} tokens would reach ${(projectedPercent.toFixed(1))}% of context limit. Consider optimizing soon.`,
+            stats,
+        };
+    }
+    return { ok: true, stats };
+}
+export async function getOptimizationSuggestions(projectPath) {
+    const project = await requireProject(projectPath);
+    const projectId = project.id;
+    const db = createDatabaseClient(await getDb());
+    const schema = await getSchema();
+    const memories = schema.memories;
+    const candidates = await db
+        .select({
+        id: memories.id,
+        type: memories.type,
+        content: memories.content,
+        tokens: memories.tokensEstimate,
+        importanceScore: memories.importanceScore,
+        accessCount: memories.accessCount,
+        createdAt: memories.createdAt,
+        isPinned: memories.isPinned,
+        isProtected: memories.isProtected,
+    })
+        .from(memories)
+        .where(eq(memories.projectId, projectId))
+        .orderBy(sql `(importance_score * 0.4 + (100 - COALESCE(access_count, 0)) * 0.3 + (strftime('%s', 'now') - created_at / 1000) / 86400 * 0.3) ASC`)
+        .limit(20);
+    const suggestions = [];
+    for (const mem of candidates) {
+        const tokens = mem.tokens || estimateTokens(mem.content || '');
+        const contentPreview = mem.content?.substring(0, 100) + '...';
+        const isPinned = mem.isPinned === 1 || mem.isPinned === true;
+        const isProtected = mem.isProtected === 1 || mem.isProtected === true;
+        const accessCount = mem.accessCount || 0;
+        const importanceScore = mem.importanceScore || 50;
+        if (isPinned || isProtected) {
+            continue;
+        }
+        if (importanceScore < 30 && accessCount < 3) {
+            suggestions.push({
+                type: 'drop',
+                memoryId: mem.id,
+                memoryType: mem.type,
+                contentPreview,
+                tokens,
+                reason: `Low importance (${importanceScore}) and rarely accessed (${accessCount} times)`,
+                priority: 1,
+            });
+        }
+        else if (importanceScore < 50 && tokens > 500) {
+            suggestions.push({
+                type: 'summarize',
+                memoryId: mem.id,
+                memoryType: mem.type,
+                contentPreview,
+                tokens,
+                reason: `Large memory (${tokens} tokens) with moderate importance`,
+                priority: 2,
+            });
+        }
+        else if (tokens > 1000) {
+            suggestions.push({
+                type: 'consolidate',
+                memoryId: mem.id,
+                memoryType: mem.type,
+                contentPreview,
+                tokens,
+                reason: `Very large memory (${tokens} tokens) - candidate for consolidation`,
+                priority: 3,
+            });
+        }
+    }
+    return suggestions.sort((a, b) => a.priority - b.priority).slice(0, 10);
+}
+export async function getContextWindowStatus(projectPath) {
+    const project = await requireProject(projectPath);
+    const projectId = project.id;
+    const db = createDatabaseClient(await getDb());
+    const schema = await getSchema();
+    const [usage, suggestions] = await Promise.all([
+        getTokenUsage(projectPath),
+        getOptimizationSuggestions(projectPath),
+    ]);
+    const memoryCount = await db
+        .select({ count: sql `COUNT(*)` })
+        .from(schema.memories)
+        .where(eq(schema.memories.projectId, projectId));
+    const coreMemorySections = await db
+        .select({ count: sql `COUNT(*)` })
+        .from(schema.coreMemory)
+        .where(eq(schema.coreMemory.projectId, projectId));
+    return {
+        config: DEFAULT_CONTEXT_CONFIG,
+        usage,
+        suggestions,
+        memoryCount: memoryCount[0]?.count || 0,
+        coreMemorySections: coreMemorySections[0]?.count || 0,
+    };
+}
+//# sourceMappingURL=context-window.js.map

package/dist/core/context/context.js

@@ -0,0 +1,22 @@
+import { requireProject } from '../projects.js';
+import { getRecent } from '../memory/memories.js';
+import { getObservations } from '../ingestion/learnings.js';
+import { getEntitiesForProject } from '../search/entities.js';
+import { validateLimit } from '../lib/validation.js';
+export async function getProjectContext(input) {
+    const project = await requireProject(input.project);
+    const include = input.include ?? ['memories', 'observations'];
+    const limit = validateLimit(input.limit, 10, 1, 100);
+    const result = { project };
+    if (include.includes('memories')) {
+        result.memories = await getRecent(project.path, limit);
+    }
+    if (include.includes('observations')) {
+        result.observations = await getObservations(project.path, limit);
+    }
+    if (include.includes('entities')) {
+        result.entities = await getEntitiesForProject(project.path, limit);
+    }
+    return result;
+}
+//# sourceMappingURL=context.js.map

package/dist/core/embeddings.d.ts

@@ -1,5 +1,5 @@
 import { MultimodalInput } from './embeddings/google-multimodal.js';
-export type EmbeddingProvider = 'local' | 'openai' | 'ollama' | 'google' | 'none' | 'auto';
+export type EmbeddingProvider = 'local' | 'openai' | 'ollama' | 'lmstudio' | 'google' | 'none' | 'auto';
 export declare function getEmbedding(input: string | MultimodalInput): Promise<number[] | null>;
 /**
  * Get embeddings for multiple inputs in parallel batches

package/dist/core/embeddings.js

@@ -125,6 +125,9 @@ export async function getEmbedding(input) {
         else if (provider === 'ollama') {
             result = await getOllamaEmbedding(textInput);
         }
+        else if (provider === 'lmstudio') {
+            result = await getLmStudioEmbedding(textInput);
+        }
         else if (provider === 'local') {
             result = getLocalEmbedding(textInput);
         }
@@ -136,6 +139,9 @@ export async function getEmbedding(input) {
             if (!result && config.ollamaUrl) {
                 result = await getOllamaEmbedding(textInput);
             }
+            if (!result && config.lmStudioUrl) {
+                result = await getLmStudioEmbedding(textInput);
+            }
             if (!result) {
                 result = getLocalEmbedding(textInput);
             }
@@ -306,7 +312,7 @@ async function getOllamaEmbedding(input) {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify({
-                model: config.ollamaEmbeddingModel,
+                model: config.ollamaEmbeddingModel || 'nomic-embed-text',
                 prompt: input,
             }),
         }, config.ollamaTimeoutMs);
@@ -323,13 +329,37 @@ async function getOllamaEmbedding(input) {
         return null; // Return null to allow fallback
     }
 }
+// LM Studio uses OpenAI-compatible API
+async function getLmStudioEmbedding(input) {
+    try {
+        const response = await fetchWithRetryAndTimeout(`${config.lmStudioUrl}/v1/embeddings`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                model: config.lmStudioEmbeddingModel || 'text-embedding-nomic-embed-text-v1.5',
+                input: input,
+            }),
+        }, config.ollamaTimeoutMs); // Reuse Ollama timeout
+        if (!response.ok) {
+            const message = await response.text();
+            logger.warn(`LM Studio embeddings failed: ${response.status} ${message}`);
+            return null; // Return null to allow fallback
+        }
+        const payload = await response.json();
+        return payload.data?.[0]?.embedding ?? null;
+    }
+    catch (error) {
+        logger.warn('LM Studio embeddings error:', { error: error });
+        return null; // Return null to allow fallback
+    }
+}
 /**
  * Check health of all configured embedding providers
  * Returns availability and latency for each provider
  */
 export async function checkEmbeddingProviderHealth() {
     const results = new Map();
-    const providers = ['local', 'openai', 'ollama', 'google', 'none', 'auto'];
+    const providers = ['local', 'openai', 'ollama', 'lmstudio', 'google', 'none', 'auto'];
     // Test local provider (always available)
     results.set('local', { available: true, latencyMs: 0 });
     // Test OpenAI if configured
@@ -376,6 +406,28 @@ export async function checkEmbeddingProviderHealth() {
     else {
         results.set('ollama', { available: false, error: 'Not configured' });
     }
+    // Test LM Studio if configured
+    if (config.lmStudioUrl) {
+        const start = Date.now();
+        try {
+            const testInput = 'health check';
+            const embedding = await withRetry(() => withTimeout(getLmStudioEmbedding(testInput), config.ollamaTimeoutMs), config.embeddingsMaxRetries, config.embeddingsRetryDelayMs);
+            const latency = Date.now() - start;
+            results.set('lmstudio', {
+                available: embedding !== null && embedding.length > 0,
+                latencyMs: latency
+            });
+        }
+        catch (error) {
+            results.set('lmstudio', {
+                available: false,
+                error: error.message
+            });
+        }
+    }
+    else {
+        results.set('lmstudio', { available: false, error: 'Not configured' });
+    }
     // Test Google if configured
     if (config.googleCloudApiKey || config.googleCloudProject) {
         const start = Date.now();

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

@@ -0,0 +1,63 @@
+/**
+ * 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

@@ -0,0 +1,173 @@
+/**
+ * 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/external-folder/index.d.ts

@@ -0,0 +1,102 @@
+/**
+ * External Folder Memory Manager
+ *
+ * Wraps QMD to treat an external folder as a secondary memory layer.
+ * - Writes hot memories to daily notes (YYYY-MM-DD.md) with frontmatter
+ * - Uses QMD to search both Squish DB and external folder
+ * - Auto-indexes on mount and write
+ *
+ * Usage:
+ *   squish mount /path/to/folder    # Enable external memory
+ *   squish mount status             # Show status
+ *   squish mount unmount            # Disable
+ */
+import type { MemoryRecord, MemoryType } from '../memory/memories.js';
+export interface ExternalMemoryConfig {
+    enabled: boolean;
+    path: string;
+}
+export interface ExternalMemoryStatus {
+    mounted: boolean;
+    path: string | null;
+    qmdIndexed: boolean;
+    memoryCount: number;
+    lastIndexed: string | null;
+}
+export interface MemoryAsMarkdown {
+    id: string;
+    type: MemoryType;
+    content: string;
+    tags: string[];
+    createdAt: string;
+    confidence?: string;
+    projectId?: string | null;
+}
+/**
+ * External Folder Memory Manager class
+ */
+export declare class ExternalFolderMemory {
+    private mountedPath;
+    /**
+     * Check if external memory is enabled and mounted
+     */
+    isEnabled(): boolean;
+    /**
+     * Get the mounted path
+     */
+    getPath(): string | null;
+    /**
+     * Mount external memory at a path
+     * Creates folder if needed, initializes structure
+     */
+    mount(path: string): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Unmount external memory
+     */
+    unmount(): {
+        success: boolean;
+    };
+    /**
+     * Ensure QMD indexes the external folder
+     */
+    ensureIndexed(folderPath?: string): Promise<boolean>;
+    /**
+     * Write a memory to the external folder (daily note)
+     */
+    writeMemory(memory: MemoryAsMarkdown): Promise<{
+        success: boolean;
+        error?: string;
+    }>;
+    /**
+     * Trigger background re-index via QMD
+     */
+    private triggerReindex;
+    /**
+     * Get current status of external memory
+     */
+    getStatus(): Promise<ExternalMemoryStatus>;
+    /**
+     * Check if folder is indexed by QMD
+     */
+    private checkQMDIndexed;
+    /**
+     * Convert a MemoryRecord to MemoryAsMarkdown format
+     */
+    toMarkdownFormat(memory: MemoryRecord): MemoryAsMarkdown;
+}
+/**
+ * Get the singleton ExternalFolderMemory instance
+ */
+export declare function getExternalMemory(): ExternalFolderMemory;
+/**
+ * Check if external memory is enabled
+ */
+export declare function isExternalMemoryEnabled(): boolean;
+/**
+ * Get external memory path
+ */
+export declare function getExternalMemoryPath(): string | null;
+//# sourceMappingURL=index.d.ts.map