squish-memory 1.0.2 → 1.2.0

package/dist/core/ingestion/learnings.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Learnings Module
+ * Agent learnings: success, failure, fix, insight
+ * With auto-linking to similar memories and learnings
+ */
+export type LearningType = 'success' | 'failure' | 'fix' | 'insight';
+export interface LearningInput {
+    type: LearningType;
+    content: string;
+    context?: string;
+    action?: string;
+    target?: string;
+    project?: string;
+    memoryId?: string;
+    autoLink?: boolean;
+}
+export interface LearningRecord {
+    id: string;
+    projectId?: string | null;
+    conversationId?: string | null;
+    type: LearningType;
+    action: string;
+    target?: string | null;
+    summary: string;
+    details?: Record<string, unknown> | null;
+    memoryId?: string | null;
+    isImported?: boolean;
+    createdAt?: string | null;
+}
+/**
+ * Create a learning and optionally auto-link to similar memories/learnings
+ */
+export declare function createLearning(input: LearningInput): Promise<LearningRecord>;
+/**
+ * Get learnings for a project
+ */
+export declare function getLearnings(projectPath: string, limit: number): Promise<LearningRecord[]>;
+/**
+ * Get recent learnings
+ */
+export declare function getRecentLearnings(projectPath: string, limit?: number): Promise<LearningRecord[]>;
+/**
+ * Get learning by ID
+ */
+export declare function getLearningById(learningId: string): Promise<LearningRecord | null>;
+/**
+ * Get learnings linked to a specific memory
+ */
+export declare function getLearningsForMemory(memoryId: string): Promise<LearningRecord[]>;
+/**
+ * Delete a learning
+ */
+export declare function deleteLearning(learningId: string): Promise<boolean>;
+export declare const getObservations: typeof getLearnings;
+export declare const getRecentObservations: typeof getRecentLearnings;
+export declare const getObservationById: typeof getLearningById;
+//# sourceMappingURL=learnings.d.ts.map

package/dist/core/ingestion/learnings.js

@@ -0,0 +1,205 @@
+/**
+ * Learnings Module
+ * Agent learnings: success, failure, fix, insight
+ * With auto-linking to similar memories and learnings
+ */
+import { randomUUID } from 'crypto';
+import { desc, eq } from 'drizzle-orm';
+import { getEmbedding } from '../embeddings.js';
+import { getOrCreateProject, requireProject } from '../projects.js';
+import { serializeMetadata, deserializeMetadata } from '../memory/serialization.js';
+import { normalizeTimestamp, prepareEmbedding } from '../lib/utils.js';
+import { logger } from '../logger.js';
+import { getDbClient } from '../lib/db-client.js';
+import { createAssociation } from '../associations.js';
+import { search } from '../memory/memories.js';
+import { updateAgentPreference } from '../agent-preferences.js';
+/**
+ * Create a learning and optionally auto-link to similar memories/learnings
+ */
+export async function createLearning(input) {
+    const { db, schema } = await getDbClient();
+    const project = await getOrCreateProject(input.project);
+    const embedding = await getEmbedding(input.content);
+    const id = randomUUID();
+    const learningType = input.type;
+    const autoLink = input.autoLink !== false; // default true
+    // Build details with learning metadata
+    const details = serializeMetadata({
+        learningType: learningType,
+        learningContent: input.content,
+        learningContext: input.context,
+    });
+    const embeddingValues = prepareEmbedding(embedding);
+    // Insert the learning
+    await db.insert(schema.learnings).values({
+        id,
+        projectId: project?.id ?? null,
+        type: learningType,
+        action: input.action ?? input.content,
+        summary: input.context || input.content,
+        target: input.target ?? null,
+        details,
+        memoryId: input.memoryId ?? null,
+        ...embeddingValues,
+        createdAt: new Date(),
+    });
+    // If memoryId provided, create bidirectional link
+    if (input.memoryId) {
+        await createAssociation(input.memoryId, // from memory
+        id, // to learning
+        'relates_to', 1);
+    }
+    // Auto-link to similar memories and learnings (if enabled)
+    if (autoLink) {
+        await autoLinkLearning(id, input.content, project?.id ?? null);
+    }
+    // Extract and store agent preferences from this learning
+    await updateAgentPreference(project?.id ?? 'default', input.content, id);
+    return {
+        id,
+        projectId: project?.id ?? null,
+        conversationId: null,
+        type: learningType,
+        action: input.action ?? input.content,
+        target: input.target ?? null,
+        summary: input.context || input.content,
+        details: { learningType: learningType, learningContent: input.content, learningContext: input.context },
+        memoryId: input.memoryId ?? null,
+        createdAt: new Date().toISOString(),
+    };
+}
+/**
+ * Auto-link a learning to similar memories above threshold
+ */
+async function autoLinkLearning(learningId, content, projectId) {
+    const SIMILARITY_THRESHOLD = 0.85;
+    const MAX_LINKS = 5;
+    if (!projectId)
+        return;
+    try {
+        // Search for similar memories using the search function
+        const similarMemories = await search({
+            query: content,
+            limit: MAX_LINKS,
+        });
+        // Filter by similarity threshold
+        const relevantMemories = similarMemories.filter((m) => (m.similarity ?? 0) >= SIMILARITY_THRESHOLD);
+        // Create associations with memories
+        for (const mem of relevantMemories) {
+            await createAssociation(learningId, // from learning
+            mem.id, // to memory
+            'relates_to', mem.similarity ?? 0.9);
+        }
+        logger.info(`Auto-linked learning ${learningId} to ${relevantMemories.length} memories`);
+    }
+    catch (error) {
+        logger.error('Error in auto-linking:', error);
+        // Don't fail learning creation if auto-link fails
+    }
+}
+/**
+ * Get learnings for a project
+ */
+export async function getLearnings(projectPath, limit) {
+    try {
+        const { db, schema } = await getDbClient();
+        const project = await requireProject(projectPath);
+        const rows = await db.select().from(schema.learnings)
+            .where(eq(schema.learnings.projectId, project.id))
+            .orderBy(desc(schema.learnings.createdAt))
+            .limit(limit);
+        return rows.map((row) => normalizeLearning(row));
+    }
+    catch (error) {
+        throw error;
+    }
+}
+/**
+ * Get recent learnings
+ */
+export async function getRecentLearnings(projectPath, limit = 10) {
+    try {
+        const { db, schema } = await getDbClient();
+        const project = await requireProject(projectPath);
+        const rows = await db.select().from(schema.learnings)
+            .where(eq(schema.learnings.projectId, project.id))
+            .orderBy(desc(schema.learnings.createdAt))
+            .limit(limit);
+        return rows.map((row) => normalizeLearning(row));
+    }
+    catch (error) {
+        logger.error('Error getting recent learnings', error);
+        throw error;
+    }
+}
+/**
+ * Get learning by ID
+ */
+export async function getLearningById(learningId) {
+    try {
+        const { db, schema } = await getDbClient();
+        const rows = await db.select().from(schema.learnings)
+            .where(eq(schema.learnings.id, learningId))
+            .limit(1);
+        if (rows.length === 0)
+            return null;
+        return normalizeLearning(rows[0]);
+    }
+    catch (error) {
+        logger.error('Error getting learning', error);
+        throw error;
+    }
+}
+/**
+ * Get learnings linked to a specific memory
+ */
+export async function getLearningsForMemory(memoryId) {
+    try {
+        const { db, schema } = await getDbClient();
+        const rows = await db.select().from(schema.learnings)
+            .where(eq(schema.learnings.memoryId, memoryId))
+            .orderBy(desc(schema.learnings.createdAt));
+        return rows.map((row) => normalizeLearning(row));
+    }
+    catch (error) {
+        logger.error('Error getting learnings for memory', error);
+        throw error;
+    }
+}
+/**
+ * Delete a learning
+ */
+export async function deleteLearning(learningId) {
+    try {
+        const { db, schema } = await getDbClient();
+        await db.delete(schema.learnings)
+            .where(eq(schema.learnings.id, learningId));
+        return true;
+    }
+    catch (error) {
+        logger.error('Error deleting learning', error);
+        return false;
+    }
+}
+function normalizeLearning(row) {
+    const details = deserializeMetadata(row.details ?? null);
+    return {
+        id: row.id,
+        projectId: row.projectId ?? row.project_id ?? null,
+        conversationId: row.conversationId ?? row.conversation_id ?? null,
+        type: row.type,
+        action: row.action,
+        target: row.target ?? null,
+        summary: row.summary,
+        details,
+        memoryId: row.memoryId ?? row.memory_id ?? null,
+        isImported: row.isImported ?? row.is_imported ?? false,
+        createdAt: normalizeTimestamp(row.createdAt ?? row.created_at),
+    };
+}
+// Backwards compatibility aliases
+export const getObservations = getLearnings;
+export const getRecentObservations = getRecentLearnings;
+export const getObservationById = getLearningById;
+//# sourceMappingURL=learnings.js.map

package/dist/core/ingestion/signal-engine.d.ts

@@ -0,0 +1,41 @@
+export type SignalClassification = 'discard' | 'session-only' | 'durable-distilled' | 'durable-raw+distilled';
+export interface SignalEventInput {
+    toolName: string;
+    toolInput?: Record<string, unknown>;
+    toolResult?: unknown;
+    sessionId?: string | null;
+}
+export interface SignalDecision {
+    classification: SignalClassification;
+    reasons: string[];
+    storeRaw: boolean;
+    importance: 'low' | 'medium' | 'high';
+    wakeUpPriority: 'low' | 'medium' | 'high';
+    placeHint: {
+        placeType: 'inbox' | 'ref' | 'wip' | 'sandbox' | 'board' | 'sparks' | 'archive' | null;
+        confidence: number;
+    };
+    graphHint: {
+        shouldEnrich: boolean;
+        entityTerms: string[];
+        reason?: string;
+    };
+    content: string;
+    contentHash: string;
+    estimatedSavings: number;
+}
+export interface DistillInput {
+    toolName: string;
+    command?: string;
+    content: string;
+    classification: SignalClassification;
+}
+export declare function hashSignalContent(content: string): string;
+export declare function classifySignalEvent(input: SignalEventInput): SignalDecision;
+export declare function distillSignalEvent(input: DistillInput): string;
+export declare function shouldReturnRawFallback(input: {
+    query: string;
+    hasRawFallback: boolean;
+    nuanceSuppressed: boolean;
+}): boolean;
+//# sourceMappingURL=signal-engine.d.ts.map

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

@@ -0,0 +1,201 @@
+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

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

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