squish-memory 1.0.2 → 1.1.5

package/dist/core/memory/migrate.js

@@ -0,0 +1,134 @@
+/**
+ * Memory Migration Module
+ * Migrate memories between .squish directories/databases
+ */
+import { randomUUID } from 'crypto';
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { getDbClient } from '../lib/db-client.js';
+/**
+ * Migrate memories from one .squish directory to another
+ */
+export async function migrateMemories(sourceDir, targetDir, options = {}) {
+    const { dryRun = false, deleteSource = false } = options;
+    const sourceDbPath = join(sourceDir, 'squish.db');
+    const targetDbPath = join(targetDir, 'squish.db');
+    if (!existsSync(sourceDbPath)) {
+        throw new Error(`Source database not found: ${sourceDbPath}`);
+    }
+    if (!existsSync(targetDbPath)) {
+        throw new Error(`Target database not found: ${targetDbPath}`);
+    }
+    // Use bun:sqlite for direct source DB access
+    // @ts-ignore - bun:sqlite module not found in types but works at runtime
+    const SqliteDatabase = (await import('bun:sqlite')).default;
+    const sourceDb = new SqliteDatabase(sourceDbPath, { readonly: true });
+    // Get target DB through the app's existing mechanism
+    const { db: targetDb, schema } = await getDbClient();
+    // Get all projects from source
+    const sourceProjects = sourceDb.query('SELECT * FROM projects').all();
+    // Map old project IDs to new project IDs
+    const projectIdMap = new Map();
+    for (const project of sourceProjects) {
+        // Check if project with same path exists in target
+        const existing = await targetDb.select()
+            .from(schema.projects)
+            .where((tbl, { eq }) => eq(tbl.path, project.path))
+            .limit(1);
+        if (existing.length > 0) {
+            projectIdMap.set(project.id, existing[0].id);
+        }
+        else {
+            // Create new project in target
+            const newId = randomUUID();
+            await targetDb.insert(schema.projects).values({
+                id: newId,
+                path: project.path,
+                name: project.name || 'migrated',
+                createdAt: new Date(),
+            });
+            projectIdMap.set(project.id, newId);
+        }
+    }
+    // Migrate memories
+    const sourceMemories = sourceDb.query('SELECT * FROM memories').all();
+    let memoriesCopied = 0;
+    for (const mem of sourceMemories) {
+        const oldProjectId = mem.project_id;
+        const newProjectId = projectIdMap.get(oldProjectId);
+        if (!newProjectId) {
+            console.warn(`Skipping memory ${mem.id}: no project mapping found`);
+            continue;
+        }
+        if (!dryRun) {
+            // Add 'imported' tag to track migrated memories
+            const existingTags = mem.tags ? JSON.parse(mem.tags) : [];
+            const newTags = [...existingTags, 'imported'];
+            await targetDb.insert(schema.memories).values({
+                id: randomUUID(),
+                projectId: newProjectId,
+                type: mem.type,
+                content: mem.content,
+                summary: mem.summary,
+                source: mem.source || 'migrated',
+                confidence: mem.confidence ?? 50,
+                confidenceLevel: mem.confidence_level || 'speculative',
+                tags: newTags,
+                metadata: { ...mem.metadata, migratedAt: new Date().toISOString(), originalId: mem.id },
+                isActive: mem.is_active ?? 1,
+                createdAt: mem.created_at ? new Date(mem.created_at * 1000) : new Date(),
+                updatedAt: new Date(),
+            });
+        }
+        memoriesCopied++;
+    }
+    // Migrate learnings (renamed from observations)
+    const sourceLearnings = sourceDb.query('SELECT * FROM learnings').all();
+    let learningsCopied = 0;
+    for (const learn of sourceLearnings) {
+        const oldProjectId = learn.project_id;
+        const newProjectId = projectIdMap.get(oldProjectId);
+        if (!newProjectId)
+            continue;
+        if (!dryRun) {
+            // Add is_imported flag to track migrated learnings
+            await targetDb.insert(schema.learnings).values({
+                id: randomUUID(),
+                projectId: newProjectId,
+                type: learn.type,
+                action: learn.action,
+                summary: learn.summary,
+                target: learn.target,
+                details: learn.details,
+                isImported: true,
+                createdAt: new Date(),
+            });
+        }
+        learningsCopied++;
+    }
+    // Migrate memory associations (simplified - skip for now)
+    const sourceAssoc = sourceDb.query('SELECT * FROM memory_associations').all();
+    let associationsCopied = 0;
+    if (!dryRun && sourceAssoc.length > 0) {
+        console.warn(`Note: ${sourceAssoc.length} associations not migrated (requires ID mapping)`);
+    }
+    // Close source DB
+    sourceDb.close();
+    // Delete source if requested
+    let sourceDeleted = false;
+    if (!dryRun && deleteSource && memoriesCopied > 0) {
+        // Implementation would delete the file
+        console.warn('Source deletion not implemented - requires manual removal');
+    }
+    return {
+        memoriesCopied,
+        observationsCopied: learningsCopied,
+        associationsCopied,
+        projectsMapped: projectIdMap.size,
+        sourceDeleted,
+        message: dryRun
+            ? 'Dry run complete - no changes made'
+            : `Successfully migrated ${memoriesCopied} memories, ${learningsCopied} learnings`
+    };
+}
+//# sourceMappingURL=migrate.js.map

package/dist/core/memory/normalization.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Memory normalization utilities
+ * Shared between memories.ts and loader.ts to avoid circular dependencies
+ */
+export interface MemoryRecord {
+    id: string;
+    projectId?: string | null;
+    type: string;
+    content: string;
+    summary?: string | null;
+    tags: string[];
+    metadata?: Record<string, unknown> | null;
+    createdAt?: string | null;
+    validFrom?: string | null;
+    validTo?: string | null;
+    recordedAt?: string | null;
+    similarity?: number;
+    importance?: number;
+    confidenceLevel?: 'certain' | 'speculative' | 'outdated' | null;
+}
+export declare function normalizeMemory(row: any): MemoryRecord;
+//# sourceMappingURL=normalization.d.ts.map

package/dist/core/memory/normalization.js

@@ -0,0 +1,26 @@
+/**
+ * Memory normalization utilities
+ * Shared between memories.ts and loader.ts to avoid circular dependencies
+ */
+import { deserializeTags, deserializeMetadata } from './serialization.js';
+import { normalizeTimestamp } from '../lib/utils.js';
+export function normalizeMemory(row) {
+    const tags = deserializeTags(row.tags ?? null);
+    const metadata = deserializeMetadata(row.metadata ?? null);
+    const createdAtStr = normalizeTimestamp(row.createdAt ?? row.created_at);
+    return {
+        id: row.id,
+        projectId: row.projectId ?? row.project_id ?? null,
+        type: row.type,
+        content: row.content,
+        summary: row.summary ?? null,
+        tags,
+        metadata,
+        createdAt: createdAtStr,
+        validFrom: row.validFrom ?? row.valid_from ?? null,
+        validTo: row.validTo ?? row.valid_to ?? null,
+        recordedAt: row.recordedAt ?? row.recorded_at ?? null,
+        confidenceLevel: row.confidenceLevel ?? row.confidence_level ?? null,
+    };
+}
+//# sourceMappingURL=normalization.js.map

package/dist/core/memory/progressive-disclosure.js

@@ -2,7 +2,7 @@ import { randomUUID } from 'crypto';
 import { eq, desc, and, sql } from 'drizzle-orm';
 import { getDb } from '../../db/index.js';
 import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../../core/database.js';
+import { createDatabaseClient } from '../storage/database.js';
 const PREVIEW_TOKENS = 50;
 const MAX_PRELOAD_CANDIDATES = 20;
 const TOKEN_ESTIMATE_CHARS = 4;

package/dist/core/memory/query-rewriter.js

@@ -2,15 +2,15 @@
 import { logger } from '../logger.js';
 import { config } from '../../config.js';
 import { expandQuery } from './query-processor.js';
-const REWRITE_SYSTEM_PROMPT = `You are a search query optimizer. Given a conversation context and a user's latest message, rewrite the message into the single most effective search query to retrieve relevant memories.
-
-Rules:
-1. Output ONLY the optimized search query - no explanations or extra text
-2. Remove filler words (please, can you, etc.)
-3. Focus on the core information need
-4. Preserve important entities (names, dates, technical terms)
-5. Add synonyms for key terms if helpful
-6. Consider what memories would be most relevant
+const REWRITE_SYSTEM_PROMPT = `You are a search query optimizer. Given a conversation context and a user's latest message, rewrite the message into the single most effective search query to retrieve relevant memories.
+
+Rules:
+1. Output ONLY the optimized search query - no explanations or extra text
+2. Remove filler words (please, can you, etc.)
+3. Focus on the core information need
+4. Preserve important entities (names, dates, technical terms)
+5. Add synonyms for key terms if helpful
+6. Consider what memories would be most relevant
 7. If the message is about recalling something specific, include those details`;
 export async function rewriteQuery(query, context) {
     if (!config.queryRewritingEnabled) {

package/dist/core/memory/serialization.d.ts

@@ -3,4 +3,8 @@ export declare function toSqliteJson(value: unknown): string | null;
 export declare function fromSqliteJson<T>(value: string | null | undefined): T | null;
 export declare function toSqliteTags(tags?: string[]): string | null;
 export declare function fromSqliteTags(value: string | null | undefined): string[];
+export declare function serializeTags(tags?: string[]): string[] | string | null | undefined;
+export declare function deserializeTags(value: string[] | string | null | undefined): string[];
+export declare function serializeMetadata(metadata: Record<string, unknown> | null | undefined): Record<string, unknown> | string | null;
+export declare function deserializeMetadata(value: Record<string, unknown> | string | null | undefined): Record<string, unknown> | null;
 //# sourceMappingURL=serialization.d.ts.map

package/dist/core/memory/serialization.js

@@ -1,3 +1,4 @@
+import { config } from '../../config.js';
 export function normalizeTags(tags) {
     return (tags || []).map((tag) => tag.trim()).filter((tag) => tag.length > 0);
 }
@@ -32,4 +33,52 @@ export function fromSqliteTags(value) {
         return value.split(',').map((tag) => tag.trim()).filter(Boolean);
     }
 }
+// High-level helpers that abstract away team mode vs local mode
+export function serializeTags(tags) {
+    if (config.isTeamMode) {
+        // PostgreSQL: store as array directly (or null if empty)
+        return tags && tags.length > 0 ? tags : null;
+    }
+    else {
+        // SQLite: store as JSON string (or null)
+        return toSqliteTags(tags);
+    }
+}
+export function deserializeTags(value) {
+    if (config.isTeamMode) {
+        // PostgreSQL: value is already an array or null/undefined
+        return Array.isArray(value) ? value : [];
+    }
+    else {
+        // SQLite: value is a JSON string or null/undefined
+        if (typeof value === 'string' || value === null || value === undefined) {
+            return fromSqliteTags(value);
+        }
+        // Unexpected type, return empty array
+        return [];
+    }
+}
+export function serializeMetadata(metadata) {
+    if (config.isTeamMode) {
+        // PostgreSQL: store object directly (or null if null/undefined, keep empty object as-is)
+        return metadata === undefined || metadata === null ? null : metadata;
+    }
+    else {
+        // SQLite: store as JSON string (or null)
+        return toSqliteJson(metadata);
+    }
+}
+export function deserializeMetadata(value) {
+    if (config.isTeamMode) {
+        // PostgreSQL: value is already an object or null/undefined
+        return value == null ? null : value;
+    }
+    else {
+        // SQLite: value is a JSON string or null/undefined
+        if (typeof value === 'string' || value === null) {
+            return fromSqliteJson(value);
+        }
+        return null;
+    }
+}
 //# sourceMappingURL=serialization.js.map

package/dist/core/memory/stats.d.ts

@@ -5,6 +5,11 @@
 export interface MemoryStats {
     totalMemories: number;
     byType: Record<string, number>;
+    totalNotes: number;
+    notesByCategory: Record<string, number>;
+    totalLearnings: number;
+    learningsByType: Record<string, number>;
+    totalLinks: number;
     oldestMemory?: string;
     newestMemory?: string;
     projectPath: string;

package/dist/core/memory/stats.js

@@ -5,8 +5,8 @@
 import { getDb } from '../../db/index.js';
 import { getSchema } from '../../db/schema.js';
 import { config } from '../../config.js';
-import { getProjectByPath } from '../../core/projects.js';
-import { createDatabaseClient } from '../../core/database.js';
+import { requireProject } from '../../core/projects.js';
+import { createDatabaseClient } from '../storage/database.js';
 /**
  * Get memory statistics for a project
  */
@@ -19,10 +19,15 @@ export async function getMemoryStats(projectPath = process.cwd()) {
         throw new Error(`Database unavailable: ${error instanceof Error ? error.message : 'Unknown error'}`);
     }
     const schema = await getSchema();
-    const project = await getProjectByPath(projectPath);
+    const project = await requireProject(projectPath);
     const stats = {
         totalMemories: 0,
         byType: {},
+        totalNotes: 0,
+        notesByCategory: {},
+        totalLearnings: 0,
+        learningsByType: {},
+        totalLinks: 0,
         projectPath,
         mode: config.isTeamMode ? 'team' : 'local'
     };
@@ -31,16 +36,16 @@ export async function getMemoryStats(projectPath = process.cwd()) {
         const countResult = await db
             .select({ count: schema.memories.id })
             .from(schema.memories)
-            .where(project ? eq(schema.memories.projectId, project.id) : undefined);
+            .where(eq(schema.memories.projectId, project.id));
         stats.totalMemories = countResult.length;
         // Count by type
         if (config.isTeamMode) {
             // PostgreSQL - use raw query for GROUP BY
-            const typeCounts = await db.execute(sql `
-        SELECT type, COUNT(*) as count
-        FROM memories
-        ${project ? sql `WHERE project_id = ${project.id}` : sql ``}
-        GROUP BY type
+            const typeCounts = await db.execute(sql `
+        SELECT type, COUNT(*) as count
+        FROM memories
+        ${sql `WHERE project_id = ${project.id}`}
+        GROUP BY type
       `);
             for (const row of typeCounts.rows) {
                 stats.byType[row.type] = Number(row.count);
@@ -51,7 +56,7 @@ export async function getMemoryStats(projectPath = process.cwd()) {
             const allMemories = await db
                 .select({ type: schema.memories.type })
                 .from(schema.memories)
-                .where(project ? eq(schema.memories.projectId, project.id) : undefined);
+                .where(eq(schema.memories.projectId, project.id));
             for (const mem of allMemories) {
                 const type = mem.type || 'unknown';
                 stats.byType[type] = (stats.byType[type] || 0) + 1;
@@ -61,13 +66,13 @@ export async function getMemoryStats(projectPath = process.cwd()) {
         const oldest = await db
             .select({ createdAt: schema.memories.createdAt })
             .from(schema.memories)
-            .where(project ? eq(schema.memories.projectId, project.id) : undefined)
+            .where(eq(schema.memories.projectId, project.id))
             .orderBy(asc(schema.memories.createdAt))
             .limit(1);
         const newest = await db
             .select({ createdAt: schema.memories.createdAt })
             .from(schema.memories)
-            .where(project ? eq(schema.memories.projectId, project.id) : undefined)
+            .where(eq(schema.memories.projectId, project.id))
             .orderBy(desc(schema.memories.createdAt))
             .limit(1);
         if (oldest.length > 0 && oldest[0].createdAt) {
@@ -76,6 +81,52 @@ export async function getMemoryStats(projectPath = process.cwd()) {
         if (newest.length > 0 && newest[0].createdAt) {
             stats.newestMemory = newest[0].createdAt;
         }
+        // Learnings
+        const allLearnings = await db
+            .select({ category: schema.learnings.category, type: schema.learnings.type })
+            .from(schema.learnings)
+            .where(eq(schema.learnings.projectId, project.id));
+        stats.totalNotes = allLearnings.length;
+        for (const obs of allLearnings) {
+            const cat = obs.category || 'uncategorized';
+            stats.notesByCategory[cat] = (stats.notesByCategory[cat] || 0) + 1;
+        }
+        // Learnings by type
+        const learningTypes = ['success', 'failure', 'fix', 'insight'];
+        const learningRecords = allLearnings.filter((o) => {
+            const type = o.type || '';
+            return learningTypes.includes(type.toLowerCase());
+        });
+        stats.totalLearnings = learningRecords.length;
+        // Count by type
+        for (const obs of learningRecords) {
+            const type = obs.type || 'unknown';
+            stats.learningsByType[type] = (stats.learningsByType[type] || 0) + 1;
+        }
+        // Links
+        // Links are scoped via their associated memories
+        if (config.isTeamMode) {
+            // PostgreSQL - use raw query to join through memories
+            const linksCount = await db.execute(sql `
+        SELECT COUNT(*) as count FROM memory_associations ma
+        JOIN memories m1 ON ma.from_memory_id = m1.id
+        JOIN memories m2 ON ma.to_memory_id = m2.id
+        ${project ? sql `WHERE m1.project_id = ${project.id} OR m2.project_id = ${project.id}` : sql ``}
+      `);
+            stats.totalLinks = Number(linksCount.rows[0]?.count || 0);
+        }
+        else {
+            // SQLite - get all and filter in memory
+            const allLinks = await db
+                .select({
+                fromProjectId: schema.memories.projectId,
+                toProjectId: schema.memories.projectId
+            })
+                .from(schema.memoryAssociations)
+                .innerJoin(schema.memories, eq(schema.memoryAssociations.fromMemoryId, schema.memories.id))
+                .where(project ? eq(schema.memories.projectId, project.id) : undefined);
+            stats.totalLinks = allLinks.length;
+        }
     }
     catch (error) {
         // Return empty stats on error

package/dist/core/memory/temporal-facts.js

@@ -16,6 +16,10 @@ import { parseTemporalFacts } from './temporal-parser.js';
 export async function checkTemporalValidity(memoryId) {
     try {
         const db = await getDb();
+        if (!db) {
+            // Graceful fallback when database is unavailable
+            return { isValid: true, confidence: 0.5 };
+        }
         const schema = await getSchema();
         const memories = await db
             .select()
@@ -75,6 +79,10 @@ export async function supersedeOldTemporalFacts(newMemoryId, content, projectId)
     };
     try {
         const db = await getDb();
+        if (!db) {
+            // Graceful fallback when database is unavailable
+            return result;
+        }
         const schema = await getSchema();
         // Parse temporal facts from new content
         const temporalFacts = await parseTemporalFacts(content);
@@ -180,6 +188,10 @@ export async function cleanupExpiredTemporalFacts(projectId) {
     let expiredCount = 0;
     try {
         const db = await getDb();
+        if (!db) {
+            // Graceful fallback when database is unavailable
+            return 0;
+        }
         const schema = await getSchema();
         const now = new Date();
         const whereClause = projectId
@@ -217,6 +229,15 @@ export async function cleanupExpiredTemporalFacts(projectId) {
 export async function getTemporalFactsStats(projectId) {
     try {
         const db = await getDb();
+        if (!db) {
+            // Graceful fallback when database is unavailable
+            return {
+                totalTemporalFacts: 0,
+                validFacts: 0,
+                expiredFacts: 0,
+                supersededFacts: 0,
+            };
+        }
         const schema = await getSchema();
         const now = new Date();
         const whereClause = projectId

package/dist/core/memory/write-gate.js

@@ -3,7 +3,7 @@
  * Validates memories before writing to ensure quality, security, and consistency
  * Integrates secret detection, trigger detection, and content validation
  */
-import { detectSecrets, redactSecrets } from '../secret-detector.js';
+import { detectSecrets, redactSecrets } from '../security/secret-detector.js';
 import { detectMemorySignals } from './trigger-detector.js';
 import { resolveContradictions } from './contradiction-resolver.js';
 import { logger } from '../logger.js';

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

@@ -0,0 +1,30 @@
+/** 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 future import feature)
+ */
+export declare function readFromVault(vaultPath: string): Promise<ObsidianMemoryInput[]>;
+//# sourceMappingURL=obsidian-vault.d.ts.map

package/dist/core/obsidian-vault.js

@@ -0,0 +1,94 @@
+/** Obsidian Vault Integration
+ *
+ * Appends hot memories to Obsidian daily notes
+ * Format: YYYY-MM-DD.md with memory blocks
+ */
+import { existsSync, mkdirSync, appendFileSync } from 'fs';
+import { join } from 'path';
+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 future import feature)
+ */
+export async function readFromVault(vaultPath) {
+    // Future: Read .md files and parse memory blocks
+    // For MVP, this is placeholder
+    logger.info(`[Obsidian] readFromVault called for: ${vaultPath}`);
+    return [];
+}
+//# sourceMappingURL=obsidian-vault.js.map

package/dist/core/places/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Places Module - Spatial memory organization (Method of Loci)
+ *
+ * Exports:
+ * - places.ts: CRUD operations for places
+ * - rules.ts: Auto-assignment rules engine
+ * - memory-places.ts: Memory-to-place assignments
+ * - walking.ts: Sequential walking through places
+ */
+export * from './places.js';
+export * from './rules.js';
+export * from './memory-places.js';
+export * from './walking.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/core/places/index.js

@@ -0,0 +1,14 @@
+/**
+ * Places Module - Spatial memory organization (Method of Loci)
+ *
+ * Exports:
+ * - places.ts: CRUD operations for places
+ * - rules.ts: Auto-assignment rules engine
+ * - memory-places.ts: Memory-to-place assignments
+ * - walking.ts: Sequential walking through places
+ */
+export * from './places.js';
+export * from './rules.js';
+export * from './memory-places.js';
+export * from './walking.js';
+//# sourceMappingURL=index.js.map