squish-memory 1.2.0 → 1.2.1

package/dist/core/ingestion/signal-engine.js

@@ -1,201 +0,0 @@
-import { createHash } from 'crypto';
-function normalizeContent(toolResult) {
-    if (typeof toolResult === 'string')
-        return toolResult;
-    if (toolResult == null)
-        return '';
-    if (typeof toolResult === 'object') {
-        try {
-            return JSON.stringify(toolResult, null, 2);
-        }
-        catch {
-            return String(toolResult);
-        }
-    }
-    return String(toolResult);
-}
-function estimateNoiseSavings(raw, distilled) {
-    return Math.max(0, raw.length - distilled.length);
-}
-function extractEntityTerms(content) {
-    const matches = content.match(/\b([A-Z][A-Za-z0-9]+|[a-z]+(?:\.[a-z0-9_-]+)+|[A-Za-z0-9_-]+\.ts)\b/g) ?? [];
-    return [...new Set(matches.filter((term) => term.length > 2))].slice(0, 6);
-}
-function inferPlaceHint(toolName, normalized) {
-    if (['write', 'edit', 'multiedit'].includes(toolName.toLowerCase()) || /\b(fix|bug|implement|refactor|edited|wrote)\b/.test(normalized)) {
-        return { placeType: 'wip', confidence: 0.88 };
-    }
-    if (/\b(test|assertionerror|traceback|exception|experiment|verify)\b/.test(normalized)) {
-        return { placeType: 'sandbox', confidence: 0.92 };
-    }
-    if (/\b(hypothesis|plan|decided|roadmap|task|todo|investigate)\b/.test(normalized)) {
-        return { placeType: 'board', confidence: 0.74 };
-    }
-    if (/\b(research|docs|pattern|reference|api|architecture)\b/.test(normalized)) {
-        return { placeType: 'ref', confidence: 0.72 };
-    }
-    if (/\b(idea|explore|future|concept)\b/.test(normalized)) {
-        return { placeType: 'sparks', confidence: 0.68 };
-    }
-    return { placeType: null, confidence: 0 };
-}
-function inferGraphHint(normalized, content, classification) {
-    if (classification === 'discard' || classification === 'session-only') {
-        return { shouldEnrich: false, entityTerms: [], reason: 'non-durable signal' };
-    }
-    const entityTerms = extractEntityTerms(content);
-    const hasStructuredSignal = entityTerms.length > 0 || /\b(fix|decision|preference|error|graph|ranking|entity|relationship)\b/.test(normalized);
-    if (!hasStructuredSignal) {
-        return { shouldEnrich: false, entityTerms: [], reason: 'no graph-worthy entities' };
-    }
-    return {
-        shouldEnrich: true,
-        entityTerms,
-        reason: 'durable signal with identifiable entities',
-    };
-}
-export function hashSignalContent(content) {
-    return createHash('sha1').update(content).digest('hex');
-}
-export function classifySignalEvent(input) {
-    const toolName = input.toolName;
-    const command = String(input.toolInput?.command ?? input.toolInput?.cmd ?? '');
-    const content = normalizeContent(input.toolResult);
-    const normalized = `${command}\n${content}`.toLowerCase();
-    const reasons = [];
-    const noisyCommand = /\b(npm|bun|pnpm|yarn)\s+(install|add)\b/.test(normalized) ||
-        /\bdownload(ed|ing)?\b|\bfetch(ed|ing)?\b|\bprogress\b|\bresolved\b/.test(normalized);
-    if (noisyCommand) {
-        const placeHint = inferPlaceHint(toolName, normalized);
-        reasons.push('noise filtered from install/build output');
-        return {
-            classification: 'discard',
-            reasons,
-            storeRaw: false,
-            importance: 'low',
-            wakeUpPriority: 'low',
-            placeHint,
-            graphHint: inferGraphHint(normalized, content, 'discard'),
-            content,
-            contentHash: hashSignalContent(normalized),
-            estimatedSavings: content.length,
-        };
-    }
-    if (/\b(current hypothesis|hypothesis:|investigate|trying next)\b/.test(normalized)) {
-        const placeHint = inferPlaceHint(toolName, normalized);
-        reasons.push('active session hypothesis');
-        return {
-            classification: 'session-only',
-            reasons,
-            storeRaw: false,
-            importance: 'medium',
-            wakeUpPriority: 'high',
-            placeHint,
-            graphHint: inferGraphHint(normalized, content, 'session-only'),
-            content,
-            contentHash: hashSignalContent(normalized),
-            estimatedSavings: 0,
-        };
-    }
-    if (/\bcorrection:|actually\b|\binstead of\b|\bprefer(s)?\b/.test(normalized)) {
-        const placeHint = inferPlaceHint(toolName, normalized);
-        reasons.push('correction or preference worth durable retention');
-        return {
-            classification: 'durable-distilled',
-            reasons,
-            storeRaw: false,
-            importance: 'high',
-            wakeUpPriority: 'high',
-            placeHint,
-            graphHint: inferGraphHint(normalized, content, 'durable-distilled'),
-            content,
-            contentHash: hashSignalContent(normalized),
-            estimatedSavings: estimateNoiseSavings(content, distillSignalEvent({
-                toolName,
-                command,
-                content,
-                classification: 'durable-distilled',
-            })),
-        };
-    }
-    if (/\b(fail|failed|failing|assertionerror|stack trace|traceback|exception)\b/.test(normalized) ||
-        /\b(test|pytest|vitest|jest|bun test)\b/.test(normalized)) {
-        const placeHint = inferPlaceHint(toolName, normalized);
-        reasons.push('test or debugging signal with nuance-sensitive output');
-        return {
-            classification: 'durable-raw+distilled',
-            reasons,
-            storeRaw: true,
-            importance: 'high',
-            wakeUpPriority: 'high',
-            placeHint,
-            graphHint: inferGraphHint(normalized, content, 'durable-raw+distilled'),
-            content,
-            contentHash: hashSignalContent(normalized),
-            estimatedSavings: estimateNoiseSavings(content, distillSignalEvent({
-                toolName,
-                command,
-                content,
-                classification: 'durable-raw+distilled',
-            })),
-        };
-    }
-    if (['write', 'edit', 'multiedit'].includes(toolName.toLowerCase())) {
-        const placeHint = inferPlaceHint(toolName, normalized);
-        reasons.push('meaningful file modification');
-        return {
-            classification: 'durable-distilled',
-            reasons,
-            storeRaw: false,
-            importance: 'medium',
-            wakeUpPriority: 'medium',
-            placeHint,
-            graphHint: inferGraphHint(normalized, content, 'durable-distilled'),
-            content,
-            contentHash: hashSignalContent(normalized),
-            estimatedSavings: estimateNoiseSavings(content, distillSignalEvent({
-                toolName,
-                command,
-                content,
-                classification: 'durable-distilled',
-            })),
-        };
-    }
-    reasons.push('session-scoped operational context');
-    const placeHint = inferPlaceHint(toolName, normalized);
-    return {
-        classification: 'session-only',
-        reasons,
-        storeRaw: false,
-        importance: 'low',
-        wakeUpPriority: 'low',
-        placeHint,
-        graphHint: inferGraphHint(normalized, content, 'session-only'),
-        content,
-        contentHash: hashSignalContent(normalized),
-        estimatedSavings: 0,
-    };
-}
-export function distillSignalEvent(input) {
-    const lines = input.content
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter(Boolean);
-    const important = lines.filter((line) => /\b(fail|error|exception|traceback|assert|stack|correction|prefer|decision|fix|edited|wrote)\b/i.test(line));
-    const selected = important.length > 0 ? important : lines.slice(0, 4);
-    const cleaned = selected.filter((line) => !/\b(pass(ing)?|resolved|download(ed|ing)?|progress|packages? added)\b/i.test(line));
-    if (/assertionerror|traceback|exception|stack/i.test(input.content) && !cleaned.some((line) => /assertionerror|traceback|exception|stack/i.test(line))) {
-        const extra = lines.find((line) => /assertionerror|traceback|exception|stack/i.test(line));
-        if (extra)
-            cleaned.push(extra);
-    }
-    return cleaned.slice(0, 6).join('\n');
-}
-export function shouldReturnRawFallback(input) {
-    if (!input.hasRawFallback)
-        return false;
-    if (input.nuanceSuppressed)
-        return true;
-    return /\b(raw|original|full|stack trace|traceback|stderr|stdout|rewind)\b/i.test(input.query);
-}
-//# sourceMappingURL=signal-engine.js.map

package/dist/core/integrations/obsidian-vault.d.ts

@@ -1,31 +0,0 @@
-/** Obsidian Vault Integration
- *
- * Appends hot memories to Obsidian daily notes
- * Format: YYYY-MM-DD.md with memory blocks
- */
-export interface ObsidianMemoryInput {
-    content: string;
-    id: string;
-    type: string;
-    tags: string[];
-    reasoning?: string;
-    memoryContext?: string;
-    examples?: string;
-    exceptions?: string;
-    source?: string;
-}
-/**
- * Append a memory to the daily note in Obsidian vault
- * Creates YYYY-MM-DD.md file if it doesn't exist
- */
-export declare function appendToObsidianVault(memory: ObsidianMemoryInput, vaultPath: string): Promise<void>;
-/**
- * Check if Obsidian vault is connected and accessible
- */
-export declare function isObsidianConnected(vaultPath: string): boolean;
-/**
- * Read existing memories from Obsidian vault (for import feature)
- * Scans vault for .md files and extracts memory blocks
- */
-export declare function readFromVault(vaultPath: string): Promise<ObsidianMemoryInput[]>;
-//# sourceMappingURL=obsidian-vault.d.ts.map

package/dist/core/integrations/obsidian-vault.js

@@ -1,156 +0,0 @@
-/** Obsidian Vault Integration
- *
- * Appends hot memories to Obsidian daily notes
- * Format: YYYY-MM-DD.md with memory blocks
- */
-import { existsSync, mkdirSync, appendFileSync, readFileSync, readdirSync } from 'fs';
-import { join } from 'path';
-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
- */
-export async function appendToObsidianVault(memory, vaultPath) {
-    const today = new Date();
-    const year = today.getFullYear();
-    const month = String(today.getMonth() + 1).padStart(2, '0');
-    const day = String(today.getDate()).padStart(2, '0');
-    const dateStr = `${year}-${month}-${day}`;
-    const dailyNotePath = join(vaultPath, `${dateStr}.md`);
-    // Ensure vault directory exists
-    if (!existsSync(vaultPath)) {
-        mkdirSync(vaultPath, { recursive: true });
-        logger.info(`[Obsidian] Created vault directory: ${vaultPath}`);
-    }
-    // Build memory block content
-    const memoryBlock = formatMemoryAsBlock(memory);
-    // Check if daily note exists, if not create with header
-    if (!existsSync(dailyNotePath)) {
-        const header = `# ${dateStr}\n\n## Squish Memories\n\n`;
-        appendFileSync(dailyNotePath, header, 'utf-8');
-        logger.info(`[Obsidian] Created daily note: ${dailyNotePath}`);
-    }
-    // Append memory block
-    appendFileSync(dailyNotePath, memoryBlock + '\n\n', 'utf-8');
-    logger.info(`[Obsidian] Appended memory to ${dateStr}.md`);
-}
-/**
- * Format memory as Obsidian-compatible block
- */
-function formatMemoryAsBlock(memory) {
-    const lines = [];
-    // Memory content as checkbox (can be toggled in Obsidian)
-    lines.push(`- [ ] "${memory.content}"`);
-    // Add ID reference for linking
-    lines.push(`  - **id:** \`${memory.id}\``);
-    // Type and tags
-    if (memory.type) {
-        lines.push(`  - **type:** ${memory.type}`);
-    }
-    if (memory.tags && memory.tags.length > 0) {
-        const tagList = memory.tags.map(t => `#${t.replace(/\s+/g, '-')}`).join(' ');
-        lines.push(`  - **tags:** ${tagList}`);
-    }
-    // Rich context fields
-    if (memory.source) {
-        lines.push(`  - **source:** ${memory.source}`);
-    }
-    if (memory.reasoning) {
-        lines.push(`  - **reasoning:** ${memory.reasoning}`);
-    }
-    if (memory.memoryContext) {
-        lines.push(`  - **context:** ${memory.memoryContext}`);
-    }
-    if (memory.examples) {
-        lines.push(`  - **examples:** ${memory.examples}`);
-    }
-    if (memory.exceptions) {
-        lines.push(`  - **exceptions:** ${memory.exceptions}`);
-    }
-    return lines.join('\n');
-}
-/**
- * Check if Obsidian vault is connected and accessible
- */
-export function isObsidianConnected(vaultPath) {
-    if (!vaultPath || vaultPath === '') {
-        return false;
-    }
-    // Check if path exists or can be created
-    const parentDir = vaultPath.includes('/')
-        ? vaultPath.split('/').slice(0, -1).join('/')
-        : vaultPath.split('\\').slice(0, -1).join('\\');
-    return existsSync(parentDir) || true; // Assume creatable if parent exists
-}
-/**
- * Read existing memories from Obsidian vault (for import feature)
- * Scans vault for .md files and extracts memory blocks
- */
-export async function readFromVault(vaultPath) {
-    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/layers/generator.d.ts

@@ -1,25 +0,0 @@
-/** Layer Extractor - Creates L0/L1 truncated layers for token-efficient hierarchical retrieval */
-export interface LayerGenerationConfig {
-    l0MaxLength?: number;
-    l1MaxLength?: number;
-    autoGenerate?: boolean;
-}
-export interface LayerGenerationResult {
-    l0?: string;
-    l1?: string;
-    l2?: string;
-    tokenCounts: {
-        l0: number;
-        l1: number;
-        l2: number;
-    };
-}
-/**
- * Extract L0/L1/L2 layers for content via truncation
- */
-export declare function extractLayers(content: string, config?: LayerGenerationConfig): Promise<LayerGenerationResult>;
-/**
- * Check if content should have layers auto-extracted
- */
-export declare function shouldAutoGenerate(contentLength: number): boolean;
-//# sourceMappingURL=generator.d.ts.map

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.d.ts

@@ -1,114 +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 type { DatabaseClient } from '../storage/database.js';
-import type { SchemaModule } from '../../db/schema.js';
-/**
- * Unified database client interface combining:
- * - `db`: Wrapped database client with select/insert/update/delete methods
- * - `schema`: Drizzle schema module with table definitions
- * - `raw`: Raw underlying connection for special cases (mcp-server, index, etc.)
- */
-export interface DbClient {
-    /**
-     * Wrapped database client with unified API
-     * Provides select(), insert(), update(), delete() methods
-     */
-    db: DatabaseClient;
-    /**
-     * Schema module containing table definitions
-     * Access tables via schema.tableName (e.g., schema.memories, schema.users)
-     */
-    schema: SchemaModule;
-    /**
-     * Raw underlying database connection
-     * Use for special cases that require direct access to the native driver
-     * (e.g., raw SQL queries, specific driver features)
-     */
-    raw: any;
-}
-/**
- * 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 declare function getDbClient(): Promise<DbClient>;
-/**
- * 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 declare function withDbClient<T>(operation: (client: DbClient) => Promise<T>): Promise<T>;
-//# sourceMappingURL=db-client.d.ts.map