squish-memory 1.2.0 → 1.2.1

package/dist/core/memory/bridge-discovery.js

@@ -1,291 +0,0 @@
-/**
- * Bridge Discovery
- * Discovers indirect connections between memories through shared associations
- * Uses bidirectional BFS with Dijkstra-style weight prioritization
- * Finds "waypoint" memories that connect otherwise distant memory clusters
- */
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { eq } from 'drizzle-orm';
-import { logger } from '../../core/logger.js';
-/**
- * Discover bridge memories connecting seed memory clusters
- */
-export async function discoverBridges(seedMemoryIds, projectId, options = {}) {
-    if (seedMemoryIds.length < 2) {
-        return [];
-    }
-    const maxPathLength = options.maxPathLength ?? 4;
-    const topBridges = options.topBridges ?? 10;
-    const minPathWeight = options.minPathWeight ?? 1;
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        // Fetch all associations for this project
-        const allMemories = await db
-            .select()
-            .from(schema.memories)
-            .where(eq(schema.memories.projectId, projectId));
-        const memoriesById = new Map(allMemories.map((m) => [m.id, m]));
-        // Get all associations
-        const associations = await db.select().from(schema.memoryAssociations);
-        // Build adjacency list graph
-        const graph = new Map();
-        for (const assoc of associations) {
-            if (!graph.has(assoc.fromMemoryId)) {
-                graph.set(assoc.fromMemoryId, []);
-            }
-            const edges = graph.get(assoc.fromMemoryId);
-            if (edges) {
-                edges.push({
-                    toId: assoc.toMemoryId,
-                    weight: assoc.weight || 1,
-                    type: assoc.associationType,
-                });
-            }
-        }
-        // Find all paths between seed memories
-        const pathMetrics = new Map();
-        const allPaths = [];
-        for (let i = 0; i < seedMemoryIds.length; i++) {
-            for (let j = i + 1; j < seedMemoryIds.length; j++) {
-                const start = seedMemoryIds[i];
-                const end = seedMemoryIds[j];
-                const paths = findPaths(graph, start, end, maxPathLength, minPathWeight);
-                for (const path of paths) {
-                    // Record intermediate nodes (not start or end)
-                    for (let k = 1; k < path.route.length - 1; k++) {
-                        const nodeId = path.route[k];
-                        if (!pathMetrics.has(nodeId)) {
-                            pathMetrics.set(nodeId, { pathsThrough: 0, weight: 0 });
-                        }
-                        const metrics = pathMetrics.get(nodeId);
-                        metrics.pathsThrough++;
-                        metrics.weight += path.weight;
-                    }
-                    if (options.includeExamplePaths !== false) {
-                        allPaths.push(path);
-                    }
-                }
-            }
-        }
-        // Calculate bridge scores and convert to BridgeMemory objects
-        const bridges = [];
-        for (const [memoryId, metrics] of pathMetrics.entries()) {
-            const memory = memoriesById.get(memoryId);
-            if (!memory)
-                continue;
-            // Calculate betweenness centrality normalized to 0-100
-            const bridgeScore = Math.min(100, (metrics.pathsThrough / (seedMemoryIds.length * (seedMemoryIds.length - 1))) * 1000);
-            // Calculate connection density: how many unique memories it connects
-            const connectedMemories = new Set();
-            const neighbors = graph.get(memoryId) || [];
-            for (const neighbor of neighbors) {
-                connectedMemories.add(neighbor.toId);
-            }
-            // Include reverse connections
-            for (const [fromId, edges] of graph.entries()) {
-                for (const edge of edges) {
-                    if (edge.toId === memoryId && fromId !== memoryId) {
-                        connectedMemories.add(fromId);
-                    }
-                }
-            }
-            const connectionDensity = connectedMemories.size / Math.max(1, allMemories.length);
-            // Determine importance level
-            let importance;
-            if (bridgeScore >= 50) {
-                importance = 'critical';
-            }
-            else if (bridgeScore >= 20) {
-                importance = 'major';
-            }
-            else {
-                importance = 'minor';
-            }
-            // Get example paths through this bridge
-            const examplePaths = allPaths
-                .filter((p) => p.route.includes(memoryId) &&
-                p.route.length > 1)
-                .slice(0, 3);
-            bridges.push({
-                memoryId,
-                memory,
-                bridgeScore,
-                pathsThrough: metrics.pathsThrough,
-                examplePaths,
-                connectionDensity: Math.round(connectionDensity * 1000) / 1000,
-                importance,
-            });
-        }
-        // Sort by bridge score descending
-        bridges.sort((a, b) => b.bridgeScore - a.bridgeScore);
-        logger.debug('Bridges discovered', {
-            seedMemoryCount: seedMemoryIds.length,
-            bridgeCount: bridges.length,
-            topBridges: bridges.slice(0, topBridges).map((b) => ({
-                id: b.memoryId,
-                score: b.bridgeScore,
-                importance: b.importance,
-            })),
-        });
-        return bridges.slice(0, topBridges);
-    }
-    catch (error) {
-        logger.error('Error discovering bridges', error);
-        return [];
-    }
-}
-/**
- * Find all shortest paths between two memories up to maxLength
- * Uses BFS with weight-based distance metric
- */
-function findPaths(graph, start, end, maxLength, minWeight) {
-    const paths = [];
-    const queue = [{ current: start, route: [start], weight: 0, types: [] }];
-    const visited = new Set();
-    while (queue.length > 0) {
-        const { current, route, weight, types } = queue.shift();
-        // Stop if we've exceeded max path length
-        if (route.length > maxLength)
-            continue;
-        // Skip if already visited in shorter path
-        const routeKey = route.join('->');
-        if (visited.has(routeKey))
-            continue;
-        visited.add(routeKey);
-        // Check if we reached the destination
-        if (current === end && route.length > 1) {
-            paths.push({
-                route,
-                distance: route.length - 1,
-                weight,
-                associationTypes: types,
-            });
-            continue;
-        }
-        // Explore neighbors
-        const neighbors = graph.get(current) || [];
-        for (const neighbor of neighbors) {
-            // Skip if creating a cycle (except for final destination)
-            if (neighbor.toId !== end && route.includes(neighbor.toId))
-                continue;
-            // Skip if weight below threshold
-            if (neighbor.weight < minWeight)
-                continue;
-            queue.push({
-                current: neighbor.toId,
-                route: [...route, neighbor.toId],
-                weight: weight + neighbor.weight,
-                types: [...types, neighbor.type],
-            });
-        }
-    }
-    // Sort by weight (distance metric) and keep top paths
-    paths.sort((a, b) => b.weight - a.weight);
-    return paths.slice(0, 5); // Return top 5 paths
-}
-/**
- * Get bridge memories for a single memory (find what it connects to)
- */
-export async function getMemoryBridges(memoryId, projectId, topK = 5) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        // Find memories connected to this one
-        const associations = await db
-            .select()
-            .from(schema.memoryAssociations)
-            .where(eq(schema.memoryAssociations.fromMemoryId, memoryId));
-        if (associations.length === 0) {
-            return [];
-        }
-        // Get connected memory IDs
-        const connectedIds = new Set();
-        for (const assoc of associations) {
-            connectedIds.add(assoc.toMemoryId);
-        }
-        if (connectedIds.size < 2) {
-            return [];
-        }
-        // Discover bridges between connected memories
-        const seedIds = Array.from(connectedIds);
-        const bridges = await discoverBridges(seedIds, projectId, { topBridges: topK });
-        return bridges;
-    }
-    catch (error) {
-        logger.error('Error getting memory bridges', error);
-        return [];
-    }
-}
-/**
- * Analyze overall network connectivity using bridge metrics
- */
-export async function analyzeNetworkConnectivity(projectId, topBridges = 20) {
-    try {
-        const db = await getDb();
-        const schema = await getSchema();
-        // Get all memories
-        const allMemories = await db
-            .select()
-            .from(schema.memories)
-            .where(eq(schema.memories.projectId, projectId));
-        if (allMemories.length < 2) {
-            return {
-                totalMemories: allMemories.length,
-                totalConnections: 0,
-                averageDegree: 0,
-                bridgeMemories: [],
-                networkDensity: 0,
-                clustering: { tightClusters: 0, looseClusters: 0 },
-            };
-        }
-        // Get all associations
-        const associations = await db.select().from(schema.memoryAssociations);
-        // Calculate graph metrics
-        const degree = new Map();
-        for (const memory of allMemories) {
-            degree.set(memory.id, 0);
-        }
-        for (const assoc of associations) {
-            degree.set(assoc.fromMemoryId, (degree.get(assoc.fromMemoryId) || 0) + 1);
-        }
-        const avgDegree = Array.from(degree.values()).reduce((a, b) => a + b, 0) / allMemories.length;
-        const networkDensity = (associations.length * 2) / (allMemories.length * (allMemories.length - 1));
-        // Discover bridges for all memories
-        const seedIds = allMemories.slice(0, Math.min(10, allMemories.length)).map((m) => m.id);
-        const bridges = await discoverBridges(seedIds, projectId, { topBridges });
-        // Cluster analysis based on connectivity
-        let tightClusters = 0;
-        let looseClusters = 0;
-        for (const memory of allMemories) {
-            const connectionCount = degree.get(memory.id) || 0;
-            if (connectionCount > avgDegree * 1.5) {
-                tightClusters++;
-            }
-            else if (connectionCount < avgDegree * 0.5) {
-                looseClusters++;
-            }
-        }
-        return {
-            totalMemories: allMemories.length,
-            totalConnections: associations.length,
-            averageDegree: Math.round(avgDegree * 100) / 100,
-            bridgeMemories: bridges,
-            networkDensity: Math.round(networkDensity * 10000) / 10000,
-            clustering: { tightClusters, looseClusters },
-        };
-    }
-    catch (error) {
-        logger.error('Error analyzing network connectivity', error);
-        return {
-            totalMemories: 0,
-            totalConnections: 0,
-            averageDegree: 0,
-            bridgeMemories: [],
-            networkDensity: 0,
-            clustering: { tightClusters: 0, looseClusters: 0 },
-        };
-    }
-}
-//# sourceMappingURL=bridge-discovery.js.map

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

@@ -1,27 +0,0 @@
-import { MemoryType } from './memories.js';
-export interface CategorizationResult {
-    suggestedType: MemoryType;
-    suggestedTags: string[];
-    hierarchicalTags: string[];
-    concepts: string[];
-    fileScopes: string[];
-    confidence: number;
-}
-export interface TagScore {
-    tag: string;
-    score: number;
-    isNew: boolean;
-    category: string;
-}
-export declare function categorizeMemory(content: string, existingTags?: string[]): Promise<CategorizationResult>;
-export declare function parseHierarchicalTag(tag: string): {
-    prefix: string | null;
-    name: string;
-};
-export declare function buildTagHierarchy(tags: string[]): Map<string, string[]>;
-export declare function suggestTagsFromEmbedding(content: string, existingTags: string[], similarMemories: Array<{
-    tags: string[];
-    content: string;
-}>): Promise<string[]>;
-export declare function generateTagVariants(tag: string): string[];
-//# sourceMappingURL=categorizer.d.ts.map

package/dist/core/memory/categorizer.js

@@ -1,306 +0,0 @@
-const MEMORY_TYPE_PATTERNS = [
-    {
-        type: 'decision',
-        patterns: [
-            /\b(i\s+(?:decided|chose|went\s+with|selected|picked)|we\s+(?:decided|chose|went\s+with)|the\s+(?:decision|choice)\s+(?:is|was)|let's\s+go\s+with|going\s+with\s+\w+)\b/i,
-            /\b(over\s+the\s+other|instead\s+of|x\s+over\s+y|better\s+to|best\s+(?:option|choice|approach))\b/i,
-            /\b(final\s+decision|decided\s+to|make\s+a\s+decision)\b/i,
-        ],
-        weight: 3,
-    },
-    {
-        type: 'preference',
-        patterns: [
-            /\b(i\s+(?:prefer|like|hate|dislike|love)|my\s+(?:preference|favorite)|i'd\s+rather|i\s+(?:always|never)\s+)\b/i,
-            /\b(in\s+general|i\s+tend\s+to|i\s+usually|i\s+typically)\b/i,
-            /\b(better\s+to|better\s+if|nice\s+to\s+have|prefer\s+)\b/i,
-        ],
-        weight: 2,
-    },
-    {
-        type: 'context',
-        patterns: [
-            /\b(remember\s+that|keep\s+in\s+mind|note\s+that|important:|from\s+now\s+on|going\s+forward)\b/i,
-            /\b(standard\s+(?:practice|workflow|approach)|we\s+(?:always|usually)\s+|never\s+forget)\b/i,
-            /\b(reminder:|warning:|caution:|pro-tip:|tip:\s*)\b/i,
-        ],
-        weight: 2,
-    },
-    {
-        type: 'fact',
-        patterns: [
-            /\b(is|are|was|were|has|have|uses?|depends\s+on|requires?|located\s+at|sits?\s+on)\b/i,
-            /\b(the\s+\w+\s+(?:file|directory|module|class|function|variable|config|setting))\b/i,
-            /\b(in\s+the|at\s+location|under\s+path)\b/i,
-        ],
-        weight: 1,
-    },
-];
-const TAG_CATEGORIES = {
-    'language': [
-        /\b(typescript|javascript|python|rust|go|java|c\+\+|c#|ruby|php|swift|kotlin|scala|elixir|clojure|haskell)\b/gi,
-    ],
-    'framework': [
-        /\b(react|vue|angular|svelte|nextjs|nuxt|express|fastify|nestjs|django|flask|spring|rails|laravel|\.net|unity|unreal)\b/gi,
-    ],
-    'tool': [
-        /\b(docker|kubernetes|git|github|gitlab|jenkins|travis|github\s+actions|terraform|ansible|puppet|chef)\b/gi,
-    ],
-    'database': [
-        /\b(postgresql|postgres|mysql|mongodb|redis|sqlite|elasticsearch|cassandra|dynamodb|neo4j|graphQL|prisma|drizzle)\b/gi,
-    ],
-    'concept': [
-        /\b(api|rest|graphql|websocket|oauth|jwt|ssl|tls|https?|crud|tdd|bdd|pipeline|microservices|serverless)\b/gi,
-    ],
-    'project': [
-        /\b(architecture|design|pattern|structure|directory|folder|file|module|component|service|controller|route|handler)\b/gi,
-    ],
-    'workflow': [
-        /\b(review|pr|merge|deploy|build|test|debug|optimize|refactor|legacy|deprecated|migration|upgrade)\b/gi,
-    ],
-    'error': [
-        /\b(error|bug|issue|exception|fallback|failure|crash|timeout|panic|assert|warn)\b/gi,
-    ],
-};
-const HIERARCHICAL_TAG_PREFIXES = {
-    'lang:': 'language',
-    'fw:': 'framework',
-    'db:': 'database',
-    'tool:': 'tool',
-    'concept:': 'concept',
-    'proj:': 'project',
-    'wf:': 'workflow',
-    'file:': 'file',
-    'dir:': 'directory',
-};
-export async function categorizeMemory(content, existingTags = []) {
-    const typeScores = {
-        observation: 0,
-        fact: 0,
-        decision: 0,
-        context: 0,
-        preference: 0,
-        note: 0,
-        task: 0,
-    };
-    for (const { type, patterns, weight } of MEMORY_TYPE_PATTERNS) {
-        for (const pattern of patterns) {
-            if (pattern.test(content)) {
-                typeScores[type] += weight;
-            }
-        }
-    }
-    const sortedTypes = Object.entries(typeScores)
-        .sort(([, a], [, b]) => b - a);
-    const suggestedType = sortedTypes[0][1] > 0
-        ? sortedTypes[0][0]
-        : 'observation';
-    const tagScores = await scoreAndSuggestTags(content, existingTags);
-    const suggestedTags = tagScores
-        .filter(t => t.score >= 0.3)
-        .sort((a, b) => b.score - a.score)
-        .slice(0, 5)
-        .map(t => t.tag);
-    const hierarchicalTags = suggestedTags.map((tag, idx) => {
-        const score = tagScores[idx]?.score ?? 0;
-        const category = tagScores[idx]?.category ?? 'general';
-        const prefix = Object.entries(HIERARCHICAL_TAG_PREFIXES).find(([, v]) => v === category)?.[0] ?? '';
-        return prefix ? `${prefix}${tag}` : tag;
-    });
-    const concepts = extractConcepts(content);
-    const fileScopes = extractFileScopes(content);
-    const maxScore = sortedTypes[0][1];
-    const confidence = Math.min(maxScore / 5, 1);
-    return {
-        suggestedType,
-        suggestedTags,
-        hierarchicalTags,
-        concepts,
-        fileScopes,
-        confidence,
-    };
-}
-async function scoreAndSuggestTags(content, existingTags) {
-    const contentLower = content.toLowerCase();
-    const existingLower = new Set(existingTags.map(t => t.toLowerCase()));
-    const allScores = [];
-    for (const [category, patterns] of Object.entries(TAG_CATEGORIES)) {
-        const matches = [];
-        for (const pattern of patterns) {
-            const found = contentLower.match(pattern);
-            if (found) {
-                matches.push(...found.map(m => m.toLowerCase()));
-            }
-        }
-        const uniqueMatches = [...new Set(matches)];
-        for (const match of uniqueMatches) {
-            const score = calculateTagScore(match, content, category);
-            const isNew = !existingLower.has(match);
-            allScores.push({
-                tag: match,
-                score: isNew ? score : score * 0.5,
-                isNew,
-                category,
-            });
-        }
-    }
-    const projectTags = extractProjectTags(content);
-    for (const tag of projectTags) {
-        allScores.push({
-            tag,
-            score: 0.7,
-            isNew: !existingLower.has(tag.toLowerCase()),
-            category: 'project',
-        });
-    }
-    return allScores;
-}
-function calculateTagScore(tag, content, category) {
-    const tagLength = tag.length;
-    const contentLower = content.toLowerCase();
-    const tagLower = tag.toLowerCase();
-    const occurrences = (contentLower.match(new RegExp(tagLower, 'g')) || []).length;
-    const density = occurrences * tagLength / content.length;
-    const categoryBonus = {
-        'language': 1.2,
-        'framework': 1.1,
-        'database': 1.1,
-        'tool': 1.0,
-        'concept': 0.9,
-        'project': 0.8,
-        'workflow': 0.9,
-    }[category] ?? 1.0;
-    let score = Math.min(density * 10 * categoryBonus, 1);
-    if (occurrences > 1) {
-        score = Math.min(score + 0.2, 1);
-    }
-    return Math.max(score, 0.1);
-}
-function extractConcepts(content) {
-    const concepts = [];
-    const pattern = /\b([a-z]+[A-Z][a-zA-Z0-9]*|[A-Z]+[a-z]+[A-Z][a-zA-Z0-9]*)\b/g;
-    const matches = content.match(pattern);
-    if (matches) {
-        const unique = [...new Set(matches)];
-        concepts.push(...unique.slice(0, 5));
-    }
-    const knownConcepts = [
-        'api', 'cli', 'sdk', 'ui', 'ux', 'ide', 'orm', 'mvc', 'crud', 'api',
-        'auth', 'jwt', 'oauth', 'rest', 'grpc', 'websocket', 'graphql',
-    ];
-    const found = knownConcepts.filter(c => new RegExp(`\\b${c}\\b`, 'i').test(content));
-    return [...new Set([...concepts, ...found])].slice(0, 8);
-}
-function extractFileScopes(content) {
-    const scopes = [];
-    const pathPatterns = [
-        /(['"])(\/[\w\-\.\/]+(?:\.[a-z]+)?)(['"])/g,
-        /(?:from|import|require)\s+['"]([\w\-\.\/]+)['"]/g,
-        /<([\w\-\.\/]+)(?:\.[a-z]+)?>/g,
-        /file:\s*([\w\-\.\/]+)/gi,
-        /in\s+([\w\-\.\/]+\.[a-z]+)/gi,
-    ];
-    for (const pattern of pathPatterns) {
-        let match;
-        while ((match = pattern.exec(content)) !== null) {
-            const path = match[1] || match[2] || match[3];
-            if (path && path.length < 100) {
-                const normalized = normalizeFilePath(path);
-                if (normalized && !scopes.includes(normalized)) {
-                    scopes.push(normalized);
-                }
-            }
-        }
-    }
-    return scopes.slice(0, 3);
-}
-function normalizeFilePath(path) {
-    const cleaned = path
-        .replace(/^['"]+|['"]+$/g, '')
-        .replace(/^\.\.?\/?/, '')
-        .split('/')
-        .filter(Boolean)
-        .join('/');
-    const parts = cleaned.split('/');
-    if (parts.length > 3) {
-        return parts.slice(-3).join('/');
-    }
-    return cleaned || '';
-}
-function extractProjectTags(content) {
-    const tags = [];
-    const projectPattern = /\bproject[:\-]?(\w+)/gi;
-    let match;
-    while ((match = projectPattern.exec(content)) !== null) {
-        tags.push(match[1].toLowerCase());
-    }
-    const dotfilePattern = /^\.?([a-zA-Z0-9_\-]+)\.(json|yaml|yml|toml|config|cfg|ini|env)/m;
-    const dotfileMatch = content.match(dotfilePattern);
-    if (dotfileMatch) {
-        tags.push(dotfileMatch[1].toLowerCase());
-    }
-    return tags;
-}
-export function parseHierarchicalTag(tag) {
-    for (const [prefix, _category] of Object.entries(HIERARCHICAL_TAG_PREFIXES)) {
-        if (tag.startsWith(prefix)) {
-            return { prefix, name: tag.slice(prefix.length) };
-        }
-    }
-    return { prefix: null, name: tag };
-}
-export function buildTagHierarchy(tags) {
-    const hierarchy = new Map();
-    for (const tag of tags) {
-        const { prefix, name } = parseHierarchicalTag(tag);
-        const category = prefix
-            ? Object.entries(HIERARCHICAL_TAG_PREFIXES).find(([p]) => p === prefix)?.[1] ?? 'custom'
-            : 'general';
-        if (!hierarchy.has(category)) {
-            hierarchy.set(category, []);
-        }
-        hierarchy.get(category).push(tag);
-    }
-    return hierarchy;
-}
-export async function suggestTagsFromEmbedding(content, existingTags, similarMemories) {
-    if (similarMemories.length === 0) {
-        return [];
-    }
-    const existingLower = new Set(existingTags.map(t => t.toLowerCase()));
-    const tagCounts = {};
-    for (const memory of similarMemories) {
-        for (const tag of memory.tags) {
-            if (!existingLower.has(tag.toLowerCase())) {
-                tagCounts[tag] = (tagCounts[tag] ?? 0) + 1;
-            }
-        }
-    }
-    return Object.entries(tagCounts)
-        .sort(([, a], [, b]) => b - a)
-        .filter(([, count]) => count >= 2)
-        .slice(0, 3)
-        .map(([tag]) => tag);
-}
-export function generateTagVariants(tag) {
-    const variants = [tag];
-    const lower = tag.toLowerCase();
-    const upper = tag.toUpperCase();
-    const capitalize = tag.charAt(0).toUpperCase() + tag.slice(1).toLowerCase();
-    if (lower !== tag)
-        variants.push(lower);
-    if (upper !== tag)
-        variants.push(upper);
-    if (capitalize !== tag)
-        variants.push(capitalize);
-    const snakeCase = tag.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase();
-    if (snakeCase !== tag && snakeCase !== lower) {
-        variants.push(snakeCase);
-    }
-    const kebabCase = tag.replace(/([a-z])([A-Z])/g, '$1-$2').toLowerCase();
-    if (kebabCase !== tag && kebabCase !== lower && kebabCase !== snakeCase) {
-        variants.push(kebabCase);
-    }
-    return [...new Set(variants)];
-}
-//# sourceMappingURL=categorizer.js.map

package/dist/core/memory/conflict-detector.d.ts

@@ -1,7 +0,0 @@
-export interface Conflict {
-    type: 'contradiction' | 'inconsistency' | 'outdated';
-    description: string;
-    relatedMemoryId?: string;
-}
-export declare function detectConflicts(memoryId: string, proposedContent: string): Promise<Conflict[]>;
-//# sourceMappingURL=conflict-detector.d.ts.map

package/dist/core/memory/conflict-detector.js

@@ -1,43 +0,0 @@
-import { eq, and, sql } from 'drizzle-orm';
-import { getDb } from '../../db/index.js';
-import { getSchema } from '../../db/schema.js';
-import { createDatabaseClient } from '../storage/database.js';
-export async function detectConflicts(memoryId, proposedContent) {
-    const db = createDatabaseClient(await getDb());
-    const schema = await getSchema();
-    const { memories } = schema;
-    const conflicts = [];
-    // Get current memory
-    const currentMemory = await db.select()
-        .from(memories)
-        .where(eq(memories.id, memoryId))
-        .limit(1);
-    if (currentMemory.length === 0)
-        return [];
-    // Check for temporal contradictions
-    if (currentMemory[0].validFrom && currentMemory[0].validTo) {
-        const now = new Date();
-        if (now < new Date(currentMemory[0].validFrom) || now > new Date(currentMemory[0].validTo)) {
-            conflicts.push({
-                type: 'inconsistency',
-                description: 'Current time is outside validity period',
-            });
-        }
-    }
-    // Check for semantic contradictions with other memories
-    const similarMemories = await db.select()
-        .from(memories)
-        .where(and(eq(memories.projectId, currentMemory[0].projectId), sql `memories.id != ${memoryId}`, sql `memories.content ILIKE ${proposedContent}`))
-        .limit(5);
-    for (const memory of similarMemories) {
-        if (memory.id !== memoryId) {
-            conflicts.push({
-                type: 'contradiction',
-                description: `Potential contradiction with memory ${memory.id}`,
-                relatedMemoryId: memory.id,
-            });
-        }
-    }
-    return conflicts;
-}
-//# sourceMappingURL=conflict-detector.js.map