@mem-weave/server 0.2.0

package/dist/core/config.js

@@ -0,0 +1,161 @@
+import { readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { resolve } from 'node:path';
+import { parse, printParseErrorCode } from 'jsonc-parser';
+import { z } from 'zod';
+/**
+ * MemWeave config schema, organized into sections matching the design spec (§9.9).
+ *
+ * Each section is optional and has sensible defaults so a missing config file
+ * (or partial override) still works for local development.
+ */
+// --- Section: server ---
+const ServerConfigSchema = z.object({
+    host: z.string().default('127.0.0.1'),
+    port: z.number().int().min(1).max(65535).default(3131)
+});
+// --- Section: storage ---
+const StorageConfigSchema = z.object({
+    path: z.string().default('~/.memweave/data/memweave.db')
+});
+// --- Section: auth ---
+const AuthConfigSchema = z.object({
+    defaultTenantName: z.string().default('default'),
+    deviceApiKey: z.string().default('dev-local-key'),
+    /** When true, the Bearer-token middleware is enforced on /api/v1/* (except /health). */
+    requireAuth: z.boolean().default(false)
+});
+// --- Section: embedding ---
+const EmbeddingConfigSchema = z.object({
+    provider: z.enum(['local-xenova', 'openai-compatible', 'noop']).default('noop'),
+    model: z.string().default('Xenova/nomic-embed-text-v1'),
+    dimensions: z.number().int().positive().default(768),
+    baseUrl: z.string().optional(),
+    apiKey: z.string().optional(),
+    /** Max texts to embed per background-worker batch. */
+    batchSize: z.number().int().positive().default(16)
+});
+// --- Section: llm ---
+const LlmConfigSchema = z.object({
+    provider: z.enum(['openai-compatible', 'noop']).default('noop'),
+    baseUrl: z.string().optional(),
+    apiKey: z.string().optional(),
+    model: z.string().default('gpt-4o-mini'),
+    temperature: z.number().min(0).max(2).default(0.2),
+    maxTokens: z.number().int().positive().default(2048)
+});
+// --- Section: consolidation ---
+const ConsolidationConfigSchema = z.object({
+    enabled: z.boolean().default(true),
+    intervalHours: z.number().positive().default(6),
+    accessLogRetentionDays: z.number().int().positive().default(90)
+});
+// --- Section: injection ---
+const InjectionConfigSchema = z.object({
+    sessionStartBudget: z.number().int().positive().default(1200),
+    promptDeltaBudget: z.number().int().positive().default(800),
+    filePackBudget: z.number().int().positive().default(1000),
+    failureDeltaBudget: z.number().int().positive().default(1500)
+});
+// --- Section: search (RRF + layers) ---
+const SearchConfigSchema = z.object({
+    rrfK: z.number().positive().default(60),
+    /** Per-layer recall limits before fusion. */
+    bm25Limit: z.number().int().positive().default(50),
+    vectorLimit: z.number().int().positive().default(50),
+    graphLimit: z.number().int().positive().default(30),
+    causalLimit: z.number().int().positive().default(30),
+    /** Minimum cosine similarity for vector results. */
+    vectorMinSimilarity: z.number().min(-1).max(1).default(0.55),
+    /** When true, vector/graph/causal layers are skipped (BM25-only). */
+    bm25Only: z.boolean().default(false)
+});
+// Note: we keep the top-level schema's sub-schemas marked `.optional()` because
+// Zod v4 in this project does not auto-fill sub-object defaults when the parent
+// receives `undefined`. We compensate in `loadConfig` by always parsing each
+// sub-section with `obj.section ?? {}`. The exported `MemWeaveConfig` type is
+// the *fully populated* shape (all sections always present).
+const ConfigSchema = z.object({
+    server: ServerConfigSchema.optional(),
+    storage: StorageConfigSchema.optional(),
+    auth: AuthConfigSchema.optional(),
+    embedding: EmbeddingConfigSchema.optional(),
+    llm: LlmConfigSchema.optional(),
+    consolidation: ConsolidationConfigSchema.optional(),
+    injection: InjectionConfigSchema.optional(),
+    search: SearchConfigSchema.optional()
+});
+export function expandPath(value) {
+    if (value.startsWith('~/'))
+        return resolve(homedir(), value.slice(2));
+    return resolve(value);
+}
+export function expandEnv(value) {
+    if (!value.startsWith('env://'))
+        return value;
+    const name = value.slice('env://'.length);
+    const resolved = process.env[name];
+    if (!resolved)
+        throw new Error(`Missing environment variable ${name}`);
+    return resolved;
+}
+/**
+ * Resolve any `env://NAME` placeholders in string fields. Returns a new object.
+ * Leaves non-string values untouched.
+ */
+export function resolveEnvPlaceholders(cfg) {
+    const walk = (v) => {
+        if (typeof v === 'string')
+            return expandEnv(v);
+        if (Array.isArray(v))
+            return v.map(walk);
+        if (v !== null && typeof v === 'object') {
+            const out = {};
+            for (const [k, val] of Object.entries(v))
+                out[k] = walk(val);
+            return out;
+        }
+        return v;
+    };
+    return walk(cfg);
+}
+/** Default config (no file given). */
+export function defaultConfig() {
+    return resolveEnvPlaceholders({
+        server: ServerConfigSchema.parse({}),
+        storage: StorageConfigSchema.parse({}),
+        auth: AuthConfigSchema.parse({}),
+        embedding: EmbeddingConfigSchema.parse({}),
+        llm: LlmConfigSchema.parse({}),
+        consolidation: ConsolidationConfigSchema.parse({}),
+        injection: InjectionConfigSchema.parse({}),
+        search: SearchConfigSchema.parse({})
+    });
+}
+export function loadConfig(path) {
+    let parsed = {};
+    if (path) {
+        const raw = readFileSync(path, 'utf8');
+        const errors = [];
+        parsed = parse(raw, errors);
+        if (errors.length > 0) {
+            const details = errors
+                .map((e) => `${printParseErrorCode(e.error)} at offset ${e.offset}`)
+                .join('; ');
+            throw new Error(`Invalid config file "${path}": ${details}`);
+        }
+    }
+    // Merge parsed file with defaults, section by section.
+    const obj = (parsed ?? {});
+    const cfg = {
+        server: ServerConfigSchema.parse(obj.server ?? {}),
+        storage: StorageConfigSchema.parse(obj.storage ?? {}),
+        auth: AuthConfigSchema.parse(obj.auth ?? {}),
+        embedding: EmbeddingConfigSchema.parse(obj.embedding ?? {}),
+        llm: LlmConfigSchema.parse(obj.llm ?? {}),
+        consolidation: ConsolidationConfigSchema.parse(obj.consolidation ?? {}),
+        injection: InjectionConfigSchema.parse(obj.injection ?? {}),
+        search: SearchConfigSchema.parse(obj.search ?? {})
+    };
+    return resolveEnvPlaceholders(cfg);
+}

package/dist/core/decay.js

@@ -0,0 +1,50 @@
+const TAU_TABLE = {
+    short: [
+        { min: 1, max: 3, tau: 1 },
+        { min: 4, max: 6, tau: 2 },
+        { min: 7, max: 9, tau: 7 },
+        { min: 10, max: 10, tau: 30 }
+    ],
+    medium: [
+        { min: 1, max: 3, tau: 5 },
+        { min: 4, max: 6, tau: 14 },
+        { min: 7, max: 9, tau: 30 },
+        { min: 10, max: 10, tau: 60 }
+    ],
+    long: [
+        { min: 1, max: 3, tau: 60 },
+        { min: 4, max: 6, tau: 180 },
+        { min: 7, max: 10, tau: Number.POSITIVE_INFINITY }
+    ]
+};
+const DAY_MS = 24 * 60 * 60 * 1000;
+export function initialStrengthFromImportance(importance) {
+    const bounded = Math.max(1, Math.min(10, Math.round(importance)));
+    return bounded / 10;
+}
+export function tauFor(tier, importance) {
+    const bounded = Math.max(1, Math.min(10, Math.round(importance)));
+    const row = TAU_TABLE[tier].find((entry) => bounded >= entry.min && bounded <= entry.max);
+    if (!row)
+        throw new Error(`No tau mapping for tier=${tier} importance=${bounded}`);
+    return row.tau;
+}
+export function applyDecay(input) {
+    const current = Math.max(0, Math.min(1, input.strength));
+    if (input.lastDecayAt === null)
+        return { strength: current, lastDecayAt: input.now };
+    if (!Number.isFinite(input.tau))
+        return { strength: current, lastDecayAt: input.now };
+    const elapsedDays = Math.max(0, (input.now - input.lastDecayAt) / DAY_MS);
+    const decayFactor = Math.exp(-elapsedDays / input.tau);
+    return { strength: Math.max(0, current * decayFactor), lastDecayAt: input.now };
+}
+export function reinforcementBoost(input) {
+    if (input.userConfirmed)
+        return 0.3;
+    if (input.explicitReference)
+        return 0.15;
+    if (input.usedInContext)
+        return 0.1;
+    return 0.02;
+}

package/dist/core/types.js

@@ -0,0 +1,72 @@
+import { z } from 'zod';
+export const MemoryTierSchema = z.enum(['short', 'medium', 'long']);
+export const MemoryTypeSchema = z.enum([
+    'fact',
+    'decision',
+    'preference',
+    'event',
+    'project_context',
+    'lesson',
+    'code_pattern',
+    'bug',
+    'workflow'
+]);
+export const EdgeTypeSchema = z.enum([
+    'causes',
+    'enables',
+    'contradicts',
+    'supersedes',
+    'references',
+    'related_to',
+    'before',
+    'after',
+    'duplicates',
+    'refines'
+]);
+export const ScopeKeySchema = z.enum(['project', 'domain', 'topic']);
+export const ScopeLevelSchema = z.enum(['global', 'project']);
+export const MemorySourceSchema = z.enum(['user_explicit', 'agent_capture', 'system_inferred']);
+export const SourceClientSchema = z.enum(['opencode', 'cursor', 'claude_code', 'rest_api']);
+export const ScopeTagSchema = z.object({
+    key: ScopeKeySchema,
+    value: z.string().min(1)
+});
+/**
+ * Hard limits on user-controllable memory fields. These exist to keep a
+ * buggy or malicious LLM from inserting 10MB of text, 10k concepts, etc.,
+ * which would balloon the FTS5 index and slow down every search.
+ */
+export const MEMORY_LIMITS = {
+    /** Max body length in chars. ~30k tokens; well above any single memory. */
+    CONTENT_MAX: 100_000,
+    /** Max concept count per memory. Real memories have 3-10. */
+    CONCEPTS_MAX: 50,
+    /** Max file associations per memory. */
+    FILES_MAX: 50
+};
+export const CreateMemoryInputSchema = z.object({
+    tenantId: z.string().min(1),
+    type: MemoryTypeSchema,
+    title: z.string().min(1).max(120),
+    content: z.string().min(1).max(MEMORY_LIMITS.CONTENT_MAX),
+    summary: z.string().min(1).max(500),
+    concepts: z.array(z.string().min(1).max(100)).max(MEMORY_LIMITS.CONCEPTS_MAX).default([]),
+    files: z.array(z.string().min(1).max(500)).max(MEMORY_LIMITS.FILES_MAX).default([]),
+    importance: z.number().int().min(1).max(10),
+    confidence: z.number().min(0).max(1),
+    source: MemorySourceSchema,
+    scopeLevel: ScopeLevelSchema,
+    scopes: z.array(ScopeTagSchema).default([]),
+    sourceClient: SourceClientSchema.nullable().default(null),
+    sourceDeviceId: z.string().nullable().default(null),
+    sourceSessionId: z.string().nullable().default(null)
+});
+export const AccessSourceSchema = z.enum([
+    'recall',
+    'smart_search',
+    'context_inject',
+    'file_history',
+    'graph_query',
+    'manual_view',
+    'dedup_reinforce'
+]);

package/dist/db/database.js

@@ -0,0 +1,58 @@
+import { mkdirSync } from 'node:fs';
+import { dirname } from 'node:path';
+import Database from 'better-sqlite3';
+import { SCHEMA_SQL } from './schema.js';
+import { logger } from '../server/logger.js';
+/**
+ * Default dimensions for the memory_vectors vec0 table. The actual configured
+ * dimensions come from the EmbeddingConfig; the table is created lazily by
+ * `openDatabase` and recreated when the configured dimensions change.
+ */
+export const VECTOR_DEFAULT_DIMENSIONS = 768;
+function vecTableName(dimensions) {
+    return `memory_vectors_${dimensions}`;
+}
+function ensureVecTable(db, dimensions) {
+    const tableName = vecTableName(dimensions);
+    const exists = db
+        .prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name=?`)
+        .get(tableName);
+    if (!exists) {
+        db.exec(`CREATE VIRTUAL TABLE IF NOT EXISTS ${tableName} USING vec0(
+         memory_id TEXT PRIMARY KEY,
+         tenant_id TEXT,
+         embedding float[${dimensions}]
+       )`);
+    }
+}
+export function openDatabase(path, options = {}) {
+    mkdirSync(dirname(path), { recursive: true });
+    const db = new Database(path);
+    db.exec(SCHEMA_SQL);
+    if (!options.skipVectorExtension) {
+        try {
+            // Load sqlite-vec (a no-op if the package isn't installed, but we install it
+            // as a regular dependency so the binary is always present in production).
+            // Use a dynamic import to avoid hard-failing test environments that
+            // exercise only non-vector code paths.
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            const sqliteVec = require('sqlite-vec');
+            sqliteVec.load(db);
+            const dims = options.vectorDimensions ?? VECTOR_DEFAULT_DIMENSIONS;
+            ensureVecTable(db, dims);
+        }
+        catch (err) {
+            // sqlite-vec unavailable — vector search will be a no-op
+            // (search engine handles missing vector layer gracefully).
+            // We intentionally do not throw — rest of system must work without it.
+            logger.warn({ err: err.message }, 'sqlite-vec not available, vector search disabled');
+        }
+    }
+    return db;
+}
+export function getVecTableName(dimensions) {
+    return vecTableName(dimensions);
+}
+export function transaction(db, fn) {
+    return db.transaction(fn)();
+}

package/dist/db/repositories/access-log-repo.js

@@ -0,0 +1,59 @@
+import { randomUUID } from 'node:crypto';
+export class AccessLogRepo {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    record(input) {
+        const id = randomUUID();
+        const now = Date.now();
+        this.db.prepare(`
+      INSERT INTO access_logs (id, tenant_id, memory_id, session_id, device_id, source, query, rank, score, used_in_context, accessed_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, input.tenantId, input.memoryId, input.sessionId, input.deviceId, input.source, input.query, input.rank, input.score, input.usedInContext ? 1 : 0, now);
+        return id;
+    }
+    listForMemory(tenantId, memoryId, limit) {
+        if (limit <= 0)
+            return [];
+        const rows = this.db.prepare(`
+      SELECT * FROM access_logs
+      WHERE tenant_id = ? AND memory_id = ?
+      ORDER BY accessed_at DESC, rowid DESC
+      LIMIT ?
+    `).all(tenantId, memoryId, limit);
+        return rows.map((r) => this.mapRow(r));
+    }
+    listSince(tenantId, sinceMs, limit) {
+        if (limit <= 0)
+            return [];
+        const rows = this.db.prepare(`
+      SELECT * FROM access_logs
+      WHERE tenant_id = ? AND accessed_at >= ?
+      ORDER BY accessed_at DESC, rowid DESC
+      LIMIT ?
+    `).all(tenantId, sinceMs, limit);
+        return rows.map((r) => this.mapRow(r));
+    }
+    purgeOlderThan(cutoffMs) {
+        const result = this.db.prepare(`
+      DELETE FROM access_logs WHERE accessed_at < ?
+    `).run(cutoffMs);
+        return Number(result.changes);
+    }
+    mapRow(row) {
+        return {
+            id: row.id,
+            tenantId: row.tenant_id,
+            memoryId: row.memory_id,
+            sessionId: row.session_id,
+            deviceId: row.device_id,
+            source: row.source,
+            query: row.query,
+            rank: row.rank,
+            score: row.score,
+            usedInContext: row.used_in_context === 1,
+            accessedAt: row.accessed_at
+        };
+    }
+}

package/dist/db/repositories/consolidation-run-repo.js

@@ -0,0 +1,86 @@
+import { randomUUID } from 'node:crypto';
+export class ConsolidationRunRepo {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    record(input) {
+        const id = randomUUID();
+        this.db.prepare(`
+      INSERT INTO consolidation_runs (
+        id, tenant_id, started_at, ended_at,
+        promoted_count, evicted_count, merged_count,
+        edges_created_count, contradiction_found_count,
+        promoted_ids, evicted_ids, merged_pairs,
+        dry_run, summary
+      ) VALUES (
+        @id, @tenantId, @startedAt, @endedAt,
+        @promotedCount, @evictedCount, @mergedCount,
+        @edgesCreated, @contradictionFound,
+        @promotedIds, @evictedIds, @mergedPairs,
+        @dryRun, @summary
+      )
+    `).run({
+            id,
+            tenantId: input.tenantId,
+            startedAt: input.startedAt,
+            endedAt: input.endedAt,
+            promotedCount: input.promoted.length,
+            evictedCount: input.evicted.length,
+            mergedCount: input.merged.length,
+            edgesCreated: input.edgesCreated,
+            contradictionFound: input.contradictionFound,
+            promotedIds: JSON.stringify(input.promoted),
+            evictedIds: JSON.stringify(input.evicted),
+            mergedPairs: JSON.stringify(input.merged),
+            dryRun: input.dryRun ? 1 : 0,
+            summary: input.summary
+        });
+        return id;
+    }
+    getById(tenantId, id) {
+        const row = this.db.prepare(`
+      SELECT * FROM consolidation_runs WHERE tenant_id = ? AND id = ?
+    `).get(tenantId, id);
+        if (!row)
+            return null;
+        return this.mapRow(row);
+    }
+    listRecent(tenantId, limit) {
+        if (limit <= 0)
+            return [];
+        const rows = this.db.prepare(`
+      SELECT * FROM consolidation_runs
+      WHERE tenant_id = ?
+      ORDER BY started_at DESC, rowid DESC
+      LIMIT ?
+    `).all(tenantId, limit);
+        return rows.map((r) => this.mapRow(r));
+    }
+    latestForTenant(tenantId) {
+        const row = this.db.prepare(`
+      SELECT * FROM consolidation_runs
+      WHERE tenant_id = ?
+      ORDER BY started_at DESC, rowid DESC
+      LIMIT 1
+    `).get(tenantId);
+        if (!row)
+            return null;
+        return this.mapRow(row);
+    }
+    mapRow(row) {
+        return {
+            id: row.id,
+            tenantId: row.tenant_id,
+            startedAt: row.started_at,
+            endedAt: row.ended_at,
+            promoted: JSON.parse(row.promoted_ids),
+            evicted: JSON.parse(row.evicted_ids),
+            merged: JSON.parse(row.merged_pairs),
+            edgesCreated: row.edges_created_count,
+            contradictionFound: row.contradiction_found_count,
+            dryRun: row.dry_run === 1,
+            summary: row.summary
+        };
+    }
+}

package/dist/db/repositories/device-repo.js

@@ -0,0 +1,66 @@
+import { randomUUID } from 'node:crypto';
+export class DeviceRepo {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    create(input) {
+        const id = randomUUID();
+        const now = Date.now();
+        this.db.prepare(`
+      INSERT INTO devices (id, tenant_id, name, type, api_key_hash, last_seen_at, registered_at)
+      VALUES (?, ?, ?, ?, ?, NULL, ?)
+    `).run(id, input.tenantId, input.name, input.type, input.apiKeyHash, now);
+        return {
+            id,
+            tenantId: input.tenantId,
+            name: input.name,
+            type: input.type,
+            apiKeyHash: input.apiKeyHash,
+            lastSeenAt: null,
+            registeredAt: now
+        };
+    }
+    getById(tenantId, id) {
+        const row = this.db.prepare(`
+      SELECT * FROM devices WHERE tenant_id = ? AND id = ?
+    `).get(tenantId, id);
+        if (!row)
+            return null;
+        return this.mapRow(row);
+    }
+    findByKeyHash(apiKeyHash) {
+        const row = this.db.prepare(`
+      SELECT * FROM devices WHERE api_key_hash = ? LIMIT 1
+    `).get(apiKeyHash);
+        if (!row)
+            return null;
+        return this.mapRow(row);
+    }
+    list(tenantId) {
+        const rows = this.db.prepare(`
+      SELECT * FROM devices WHERE tenant_id = ?
+      ORDER BY registered_at DESC, rowid DESC
+    `).all(tenantId);
+        return rows.map((r) => this.mapRow(r));
+    }
+    touch(id) {
+        this.db.prepare(`
+      UPDATE devices SET last_seen_at = ? WHERE id = ?
+    `).run(Date.now(), id);
+    }
+    delete(id) {
+        this.db.prepare(`DELETE FROM devices WHERE id = ?`).run(id);
+    }
+    mapRow(row) {
+        return {
+            id: row.id,
+            tenantId: row.tenant_id,
+            name: row.name,
+            type: row.type,
+            apiKeyHash: row.api_key_hash,
+            lastSeenAt: row.last_seen_at,
+            registeredAt: row.registered_at
+        };
+    }
+}

package/dist/db/repositories/edge-repo.js

@@ -0,0 +1,104 @@
+import { randomUUID } from 'node:crypto';
+export class EdgeRepo {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    create(input) {
+        const id = randomUUID();
+        const now = Date.now();
+        this.db.prepare(`
+      INSERT INTO edges (id, tenant_id, from_memory_id, to_memory_id, type, strength, reason, created_at)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `).run(id, input.tenantId, input.fromMemoryId, input.toMemoryId, input.type, input.strength, input.reason, now);
+        return {
+            id,
+            tenantId: input.tenantId,
+            fromMemoryId: input.fromMemoryId,
+            toMemoryId: input.toMemoryId,
+            type: input.type,
+            strength: input.strength,
+            reason: input.reason,
+            createdAt: now
+        };
+    }
+    getOutgoing(tenantId, memoryId) {
+        const rows = this.db.prepare(`
+      SELECT * FROM edges
+      WHERE tenant_id = ? AND from_memory_id = ?
+      ORDER BY created_at DESC
+    `).all(tenantId, memoryId);
+        return rows.map(this.mapRow);
+    }
+    getIncoming(tenantId, memoryId) {
+        const rows = this.db.prepare(`
+      SELECT * FROM edges
+      WHERE tenant_id = ? AND to_memory_id = ?
+      ORDER BY created_at DESC
+    `).all(tenantId, memoryId);
+        return rows.map(this.mapRow);
+    }
+    getNeighbors(tenantId, memoryId, direction = 'both', edgeTypes) {
+        const typeFilter = edgeTypes && edgeTypes.length > 0
+            ? `AND type IN (${edgeTypes.map(() => '?').join(',')})`
+            : '';
+        const params = [tenantId, memoryId];
+        if (edgeTypes && edgeTypes.length > 0)
+            params.push(...edgeTypes);
+        const results = [];
+        if (direction === 'out' || direction === 'both') {
+            const outRows = this.db.prepare(`
+        SELECT id, type, strength, reason, to_memory_id, created_at
+        FROM edges
+        WHERE tenant_id = ? AND from_memory_id = ? ${typeFilter}
+        ORDER BY created_at DESC
+      `).all(...params);
+            for (const r of outRows) {
+                results.push({
+                    edgeId: r.id,
+                    type: r.type,
+                    strength: r.strength,
+                    reason: r.reason,
+                    direction: 'out',
+                    neighborId: r.to_memory_id,
+                    createdAt: r.created_at
+                });
+            }
+        }
+        if (direction === 'in' || direction === 'both') {
+            const inRows = this.db.prepare(`
+        SELECT id, type, strength, reason, from_memory_id, created_at
+        FROM edges
+        WHERE tenant_id = ? AND to_memory_id = ? ${typeFilter}
+        ORDER BY created_at DESC
+      `).all(...params);
+            for (const r of inRows) {
+                results.push({
+                    edgeId: r.id,
+                    type: r.type,
+                    strength: r.strength,
+                    reason: r.reason,
+                    direction: 'in',
+                    neighborId: r.from_memory_id,
+                    createdAt: r.created_at
+                });
+            }
+        }
+        return results;
+    }
+    delete(id) {
+        this.db.prepare('DELETE FROM edges WHERE id = ?').run(id);
+    }
+    mapRow(row) {
+        return {
+            id: row.id,
+            tenantId: row.tenant_id,
+            fromMemoryId: row.from_memory_id,
+            toMemoryId: row.to_memory_id,
+            type: row.type,
+            strength: row.strength,
+            reason: row.reason,
+            createdAt: row.created_at
+        };
+    }
+}