stellar-memory 0.8.4 → 1.0.0

package/dist/storage/queries.js

@@ -1,899 +1,18 @@
-import { randomUUID } from 'node:crypto';
-import { getDatabase } from './database.js';
-import { ORBIT_ZONES } from '../engine/types.js';
-import { filterActiveMemories } from '../engine/validity.js';
-import { createLogger } from '../utils/logger.js';
-const log = createLogger('queries');
-// ---------------------------------------------------------------------------
-// Deserializers ??parse JSON fields coming out of SQLite
-// ---------------------------------------------------------------------------
-// Cast helpers ??node:sqlite returns Record<string, SQLOutputValue> from .get()/.all().
-// We cast through unknown because we know the schema guarantees the shape.
-function asRawMemory(row) {
-    return row;
-}
-function asRawSunState(row) {
-    return row;
-}
-function deserializeMemory(row) {
-    return {
-        ...row,
-        type: row.type,
-        tags: parseJsonArray(row.tags),
-        metadata: parseJsonObject(row.metadata),
-        source: row.source ?? 'manual',
-        source_path: row.source_path ?? null,
-        source_hash: row.source_hash ?? null,
-        content_hash: row.content_hash ?? null,
-        valid_from: row.valid_from ?? undefined,
-        valid_until: row.valid_until ?? undefined,
-        superseded_by: row.superseded_by ?? undefined,
-        consolidated_into: row.consolidated_into ?? undefined,
-        quality_score: row.quality_score ?? undefined,
-        is_universal: row.is_universal ? Boolean(row.is_universal) : undefined,
-    };
-}
-function deserializeConstellationEdge(row) {
-    return {
-        ...row,
-        relation: row.relation,
-        metadata: parseJsonObject(row.metadata),
-    };
-}
-function deserializeConflict(row) {
-    return {
-        ...row,
-        severity: row.severity,
-        status: row.status,
-        resolution: row.resolution ?? undefined,
-        resolved_at: row.resolved_at ?? undefined,
-    };
-}
-function deserializeObservation(row) {
-    return {
-        ...row,
-        extracted_memories: parseJsonArray(row.extracted_memories),
-        source: row.source,
-    };
-}
-function asRawDataSource(row) {
-    return row;
-}
-function deserializeDataSource(row) {
-    return {
-        ...row,
-        type: row.type,
-        status: row.status,
-        config: parseJsonObject(row.config),
-    };
-}
-function deserializeSunState(row) {
-    return {
-        ...row,
-        recent_decisions: parseJsonArray(row.recent_decisions),
-        next_steps: parseJsonArray(row.next_steps),
-        active_errors: parseJsonArray(row.active_errors),
-    };
-}
-function parseJsonArray(value) {
-    if (typeof value !== 'string' || value === '')
-        return [];
-    try {
-        const parsed = JSON.parse(value);
-        return Array.isArray(parsed) ? parsed : [];
-    }
-    catch {
-        log.warn('JSON array parse failed', { raw: String(value).slice(0, 100) });
-        return [];
-    }
-}
-function parseJsonObject(value) {
-    if (typeof value !== 'string' || value === '')
-        return {};
-    try {
-        const parsed = JSON.parse(value);
-        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
-            ? parsed
-            : {};
-    }
-    catch {
-        log.warn('JSON object parse failed', { raw: String(value).slice(0, 100) });
-        return {};
-    }
-}
-// ---------------------------------------------------------------------------
-// Memory CRUD
-// ---------------------------------------------------------------------------
-export function insertMemory(memory) {
-    const db = getDatabase();
-    const now = new Date().toISOString();
-    const id = memory.id ?? randomUUID();
-    const project = memory.project ?? 'default';
-    const content = memory.content ?? '';
-    const summary = memory.summary ?? '';
-    const type = memory.type ?? 'observation';
-    const tags = JSON.stringify(memory.tags ?? []);
-    const distance = memory.distance ?? 5.0;
-    const importance = memory.importance ?? 0.5;
-    const velocity = memory.velocity ?? 0.0;
-    const impact = memory.impact ?? 0.5;
-    const access_count = memory.access_count ?? 0;
-    const last_accessed_at = memory.last_accessed_at ?? null;
-    const metadata = JSON.stringify(memory.metadata ?? {});
-    const source = memory.source ?? 'manual';
-    const source_path = memory.source_path ?? null;
-    const source_hash = memory.source_hash ?? null;
-    const content_hash = memory.content_hash ?? null;
-    const created_at = memory.created_at ?? now;
-    const updated_at = memory.updated_at ?? now;
-    const deleted_at = memory.deleted_at ?? null;
-    const valid_from = memory.valid_from ?? null;
-    const valid_until = memory.valid_until ?? null;
-    const superseded_by = memory.superseded_by ?? null;
-    const consolidated_into = memory.consolidated_into ?? null;
-    const quality_score = memory.quality_score ?? null;
-    const is_universal = memory.is_universal ? 1 : 0;
-    db.prepare(`
-    INSERT INTO memories (
-      id, project, content, summary, type, tags,
-      distance, importance, velocity, impact,
-      access_count, last_accessed_at, metadata,
-      source, source_path, source_hash, content_hash,
-      created_at, updated_at, deleted_at,
-      valid_from, valid_until, superseded_by,
-      consolidated_into, quality_score, is_universal
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(id, project, content, summary, type, tags, distance, importance, velocity, impact, access_count, last_accessed_at, metadata, source, source_path, source_hash, content_hash, created_at, updated_at, deleted_at, valid_from, valid_until, superseded_by, consolidated_into, quality_score, is_universal);
-    // Return the fully resolved Memory object (no second DB hit needed)
-    return {
-        id, project, content, summary,
-        type: type,
-        tags: memory.tags ?? [],
-        distance, importance, velocity, impact,
-        access_count, last_accessed_at, metadata: memory.metadata ?? {},
-        source, source_path, source_hash, content_hash,
-        created_at, updated_at, deleted_at,
-        valid_from: valid_from ?? undefined,
-        valid_until: valid_until ?? undefined,
-        superseded_by: superseded_by ?? undefined,
-        consolidated_into: consolidated_into ?? undefined,
-        quality_score: quality_score ?? undefined,
-        is_universal: Boolean(is_universal),
-    };
-}
-export function getMemoryById(id) {
-    const db = getDatabase();
-    const row = db.prepare(`
-    SELECT * FROM memories WHERE id = ?
-  `).get(id);
-    return row ? deserializeMemory(asRawMemory(row)) : null;
-}
-export function getMemoryByIds(ids) {
-    if (ids.length === 0)
-        return [];
-    const db = getDatabase();
-    const placeholders = ids.map(() => '?').join(', ');
-    const rows = db.prepare(`
-    SELECT * FROM memories
-    WHERE id IN (${placeholders})
-      AND deleted_at IS NULL
-  `).all(...ids);
-    return filterActiveMemories(rows.map((r) => deserializeMemory(asRawMemory(r))));
-}
-export function getMemoriesByProject(project, includeDeleted = false) {
-    const db = getDatabase();
-    const sql = includeDeleted
-        ? `SELECT * FROM memories WHERE project = ? ORDER BY distance ASC`
-        : `SELECT * FROM memories WHERE project = ? AND deleted_at IS NULL ORDER BY distance ASC`;
-    const rows = db.prepare(sql).all(project);
-    return filterActiveMemories(rows.map((r) => deserializeMemory(asRawMemory(r))));
-}
 /**
- * Get memories created within the last `hoursAgo` hours for a project.
- * Used by auto-commit on shutdown to summarize the current session.
+ * storage/queries.ts — Barrel re-export for backward compatibility.
+ *
+ * The entire codebase imports from '../storage/queries.js'.
+ * This file re-exports everything from the domain files under queries/
+ * so no existing import paths need to change.
  */
-export function getRecentMemories(project, hoursAgo = 3) {
-    const db = getDatabase();
-    const cutoff = new Date(Date.now() - hoursAgo * 60 * 60 * 1000).toISOString();
-    const rows = db.prepare(`
-    SELECT * FROM memories
-    WHERE project = ?
-      AND deleted_at IS NULL
-      AND created_at > ?
-    ORDER BY created_at DESC
-  `).all(project, cutoff);
-    return filterActiveMemories(rows.map((r) => deserializeMemory(asRawMemory(r))));
-}
-export function getMemoriesInZone(project, zone) {
-    const db = getDatabase();
-    const { min, max } = ORBIT_ZONES[zone];
-    const rows = db.prepare(`
-    SELECT * FROM memories
-    WHERE project = ?
-      AND deleted_at IS NULL
-      AND distance >= ?
-      AND distance < ?
-    ORDER BY distance ASC
-  `).all(project, min, max);
-    return filterActiveMemories(rows.map((r) => deserializeMemory(asRawMemory(r))));
-}
-export function updateMemoryOrbit(id, distance, importance, velocity) {
-    const db = getDatabase();
-    const now = new Date().toISOString();
-    db.prepare(`
-    UPDATE memories
-    SET distance = ?, importance = ?, velocity = ?, updated_at = ?
-    WHERE id = ?
-  `).run(distance, importance, velocity, now, id);
-}
-export function updateMemoryAccess(id) {
-    const db = getDatabase();
-    const now = new Date().toISOString();
-    db.prepare(`
-    UPDATE memories
-    SET access_count = access_count + 1,
-        last_accessed_at = ?,
-        updated_at = ?
-    WHERE id = ?
-  `).run(now, now, id);
-}
-export function softDeleteMemory(id) {
-    const db = getDatabase();
-    const now = new Date().toISOString();
-    db.prepare(`
-    UPDATE memories
-    SET deleted_at = ?, updated_at = ?
-    WHERE id = ?
-  `).run(now, now, id);
-}
-// ---------------------------------------------------------------------------
-// Full-text search (FTS5)
-// ---------------------------------------------------------------------------
-/**
- * Escape a user-supplied string for use in an FTS5 MATCH clause.
- * Wraps the entire query in double-quotes and escapes internal double-quotes
- * so it is treated as a literal phrase rather than FTS5 query syntax.
- */
-function escapeFtsQuery(query) {
-    // Split into individual words, quote each one to escape FTS5 operators,
-    // then join with spaces (implicit AND). This avoids phrase-matching issues
-    // while still preventing FTS5 syntax errors from special characters.
-    const words = query.trim().split(/\s+/).filter(w => w.length > 0);
-    if (words.length === 0)
-        return '""';
-    return words.map(w => '"' + w.replace(/"/g, '""') + '"').join(' ');
-}
-export function searchMemories(project, query, limit = 20) {
-    const db = getDatabase();
-    const escapedQuery = escapeFtsQuery(query);
-    // FTS5 MATCH uses its own query syntax; we join on rowid to get the full row
-    const rows = db.prepare(`
-    SELECT m.*
-    FROM memories m
-    JOIN memories_fts fts ON m.rowid = fts.rowid
-    WHERE memories_fts MATCH ?
-      AND m.project = ?
-      AND m.deleted_at IS NULL
-      AND m.superseded_by IS NULL
-      AND (m.valid_from IS NULL OR m.valid_from <= datetime('now'))
-      AND (m.valid_until IS NULL OR m.valid_until > datetime('now'))
-    ORDER BY rank
-    LIMIT ?
-  `).all(escapedQuery, project, limit);
-    return filterActiveMemories(rows.map((r) => deserializeMemory(asRawMemory(r))));
-}
-// ---------------------------------------------------------------------------
-// Distance-ranged FTS5 search (used by tiered recall pipeline)
-// ---------------------------------------------------------------------------
-export function searchMemoriesInRange(project, query, minDistance, maxDistance, limit) {
-    const db = getDatabase();
-    const escapedQuery = escapeFtsQuery(query);
-    const rows = db.prepare(`
-    SELECT m.*
-    FROM memories m
-    JOIN memories_fts fts ON m.rowid = fts.rowid
-    WHERE memories_fts MATCH ?
-      AND m.project = ?
-      AND m.deleted_at IS NULL
-      AND m.superseded_by IS NULL
-      AND (m.valid_from IS NULL OR m.valid_from <= datetime('now'))
-      AND (m.valid_until IS NULL OR m.valid_until > datetime('now'))
-      AND m.distance >= ?
-      AND m.distance < ?
-    ORDER BY rank
-    LIMIT ?
-  `).all(escapedQuery, project, minDistance, maxDistance, limit);
-    return filterActiveMemories(rows.map((r) => deserializeMemory(asRawMemory(r))));
-}
-// ---------------------------------------------------------------------------
-// Nearest memories (by orbital distance ??closest to the "sun" first)
-// ---------------------------------------------------------------------------
-export function getNearestMemories(project, limit) {
-    const db = getDatabase();
-    const rows = db.prepare(`
-    SELECT * FROM memories
-    WHERE project = ? AND deleted_at IS NULL
-    ORDER BY distance ASC
-    LIMIT ?
-  `).all(project, limit);
-    return rows.map((r) => deserializeMemory(asRawMemory(r)));
-}
-// ---------------------------------------------------------------------------
-// Sun state
-// ---------------------------------------------------------------------------
-export function getSunState(project) {
-    const db = getDatabase();
-    const row = db.prepare(`
-    SELECT * FROM sun_state WHERE project = ?
-  `).get(project);
-    return row ? deserializeSunState(asRawSunState(row)) : null;
-}
-export function upsertSunState(state) {
-    const db = getDatabase();
-    const now = new Date().toISOString();
-    // Fetch existing row so we can merge rather than blindly overwrite fields
-    const existing = getSunState(state.project);
-    const content = state.content ?? existing?.content ?? '';
-    const current_work = state.current_work ?? existing?.current_work ?? '';
-    const recent_decisions = JSON.stringify(state.recent_decisions ?? existing?.recent_decisions ?? []);
-    const next_steps = JSON.stringify(state.next_steps ?? existing?.next_steps ?? []);
-    const active_errors = JSON.stringify(state.active_errors ?? existing?.active_errors ?? []);
-    const project_context = state.project_context ?? existing?.project_context ?? '';
-    const token_count = state.token_count ?? existing?.token_count ?? 0;
-    const last_commit_at = state.last_commit_at ?? existing?.last_commit_at ?? null;
-    db.prepare(`
-    INSERT INTO sun_state (
-      project, content, current_work,
-      recent_decisions, next_steps, active_errors,
-      project_context, token_count, last_commit_at, updated_at
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-    ON CONFLICT(project) DO UPDATE SET
-      content = excluded.content,
-      current_work = excluded.current_work,
-      recent_decisions = excluded.recent_decisions,
-      next_steps = excluded.next_steps,
-      active_errors = excluded.active_errors,
-      project_context = excluded.project_context,
-      token_count = excluded.token_count,
-      last_commit_at = excluded.last_commit_at,
-      updated_at = excluded.updated_at
-  `).run(state.project, content, current_work, recent_decisions, next_steps, active_errors, project_context, token_count, last_commit_at, now);
-}
-// ---------------------------------------------------------------------------
-// Orbit log
-// ---------------------------------------------------------------------------
-export function insertOrbitLog(change) {
-    const db = getDatabase();
-    const now = new Date().toISOString();
-    db.prepare(`
-    INSERT INTO orbit_log (
-      memory_id, project,
-      old_distance, new_distance,
-      old_importance, new_importance,
-      trigger, created_at
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(change.memory_id, change.project, change.old_distance, change.new_distance, change.old_importance, change.new_importance, change.trigger, now);
-}
-export function cleanupOrbitLog(retentionDays = 90) {
-    const db = getDatabase();
-    const cutoff = new Date(Date.now() - retentionDays * 24 * 60 * 60 * 1000).toISOString();
-    const result = db.prepare('DELETE FROM orbit_log WHERE created_at < ?').run(cutoff);
-    return Number(result.changes);
-}
-// ---------------------------------------------------------------------------
-// Source-path deduplication
-// ---------------------------------------------------------------------------
-/**
- * Check whether a memory already exists for the given source_path + source_hash.
- * Returns true if an identical (path, hash) pair is already stored and not deleted.
- */
-export function memoryExistsForSource(sourcePath, sourceHash) {
-    const db = getDatabase();
-    const row = db.prepare(`
-    SELECT id FROM memories
-    WHERE source_path = ? AND source_hash = ? AND deleted_at IS NULL
-    LIMIT 1
-  `).get(sourcePath, sourceHash);
-    return row !== undefined;
-}
-/**
- * Find a memory by source_path (regardless of hash). Used to update stale entries.
- */
-export function getMemoryBySourcePath(sourcePath) {
-    const db = getDatabase();
-    const row = db.prepare(`
-    SELECT * FROM memories
-    WHERE source_path = ? AND deleted_at IS NULL
-    LIMIT 1
-  `).get(sourcePath);
-    return row ? deserializeMemory(asRawMemory(row)) : null;
-}
-/**
- * Find a non-deleted memory in the given project that has the same content hash.
- * Used by createMemory() for content-level deduplication.
- */
-export function getMemoryByContentHash(project, contentHash) {
-    const db = getDatabase();
-    const row = db.prepare(`
-    SELECT * FROM memories
-    WHERE project = ? AND content_hash = ? AND deleted_at IS NULL
-    LIMIT 1
-  `).get(project, contentHash);
-    return row ? deserializeMemory(asRawMemory(row)) : null;
-}
-// ---------------------------------------------------------------------------
-// Data sources CRUD
-// ---------------------------------------------------------------------------
-export function insertDataSource(ds) {
-    const db = getDatabase();
-    const now = new Date().toISOString();
-    db.prepare(`
-    INSERT INTO data_sources (id, path, type, status, last_scanned_at, file_count, total_size, config, created_at, updated_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(ds.id, ds.path, ds.type, ds.status, ds.last_scanned_at ?? null, ds.file_count ?? 0, ds.total_size ?? 0, JSON.stringify(ds.config ?? {}), now, now);
-    return { ...ds, config: ds.config ?? {}, created_at: now, updated_at: now };
-}
-export function updateDataSource(id, patch) {
-    const db = getDatabase();
-    const now = new Date().toISOString();
-    const sets = ['updated_at = ?'];
-    const values = [now];
-    if (patch.status !== undefined) {
-        sets.push('status = ?');
-        values.push(patch.status);
-    }
-    if (patch.last_scanned_at !== undefined) {
-        sets.push('last_scanned_at = ?');
-        values.push(patch.last_scanned_at);
-    }
-    if (patch.file_count !== undefined) {
-        sets.push('file_count = ?');
-        values.push(patch.file_count);
-    }
-    if (patch.total_size !== undefined) {
-        sets.push('total_size = ?');
-        values.push(patch.total_size);
-    }
-    if (patch.config !== undefined) {
-        sets.push('config = ?');
-        values.push(JSON.stringify(patch.config));
-    }
-    values.push(id);
-    db.prepare(`UPDATE data_sources SET ${sets.join(', ')} WHERE id = ?`).run(...values);
-}
-export function getAllDataSources() {
-    const db = getDatabase();
-    const rows = db.prepare(`SELECT * FROM data_sources ORDER BY created_at DESC`).all();
-    return rows.map((r) => deserializeDataSource(asRawDataSource(r)));
-}
-export function getDataSourceByPath(path) {
-    const db = getDatabase();
-    const row = db.prepare(`SELECT * FROM data_sources WHERE path = ? LIMIT 1`).get(path);
-    return row ? deserializeDataSource(asRawDataSource(row)) : null;
-}
-// ---------------------------------------------------------------------------
-// Constellation queries (Knowledge Graph)
-// ---------------------------------------------------------------------------
-export function createEdge(edge) {
-    const db = getDatabase();
-    db.prepare(`
-    INSERT INTO constellation_edges (id, source_id, target_id, relation, weight, project, metadata, created_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    ON CONFLICT(source_id, target_id, relation) DO UPDATE SET
-      weight = excluded.weight,
-      metadata = excluded.metadata
-  `).run(edge.id, edge.source_id, edge.target_id, edge.relation, edge.weight, edge.project, JSON.stringify(edge.metadata ?? {}), edge.created_at);
-}
-export function getEdges(memoryId, project) {
-    const db = getDatabase();
-    const rows = db.prepare(`
-    SELECT * FROM constellation_edges
-    WHERE (source_id = ? OR target_id = ?) AND project = ?
-    ORDER BY weight DESC
-  `).all(memoryId, memoryId, project);
-    return rows.map((r) => deserializeConstellationEdge(r));
-}
-export function getConstellation(memoryId, project, depth = 1) {
-    const db = getDatabase();
-    const visitedNodeIds = new Set([memoryId]);
-    const allEdges = [];
-    let frontier = [memoryId];
-    for (let d = 0; d < depth; d++) {
-        if (frontier.length === 0)
-            break;
-        const placeholders = frontier.map(() => '?').join(', ');
-        const edgeRows = db.prepare(`
-      SELECT * FROM constellation_edges
-      WHERE (source_id IN (${placeholders}) OR target_id IN (${placeholders}))
-        AND project = ?
-    `).all(...frontier, ...frontier, project);
-        for (const r of edgeRows) {
-            const edge = deserializeConstellationEdge(r);
-            allEdges.push(edge);
-            visitedNodeIds.add(edge.source_id);
-            visitedNodeIds.add(edge.target_id);
-        }
-        frontier = [...visitedNodeIds].filter((id) => !frontier.includes(id) && id !== memoryId);
-    }
-    const nodes = getMemoryByIds([...visitedNodeIds]);
-    return { nodes, edges: allEdges };
-}
-/**
- * Get all constellation neighbors for a batch of memory IDs.
- * Returns a map from memory ID ??set of neighbor IDs.
- */
-export function getEdgesForBatch(memoryIds, project) {
-    if (memoryIds.length === 0)
-        return new Map();
-    const db = getDatabase();
-    const placeholders = memoryIds.map(() => '?').join(', ');
-    const rows = db.prepare(`
-    SELECT source_id, target_id FROM constellation_edges
-    WHERE (source_id IN (${placeholders}) OR target_id IN (${placeholders}))
-      AND project = ?
-  `).all(...memoryIds, ...memoryIds, project);
-    const idSet = new Set(memoryIds);
-    const result = new Map();
-    for (const r of rows) {
-        const row = r;
-        // For each memory in our batch, record its neighbor
-        if (idSet.has(row.source_id)) {
-            const neighbors = result.get(row.source_id) ?? new Set();
-            neighbors.add(row.target_id);
-            result.set(row.source_id, neighbors);
-        }
-        if (idSet.has(row.target_id)) {
-            const neighbors = result.get(row.target_id) ?? new Set();
-            neighbors.add(row.source_id);
-            result.set(row.target_id, neighbors);
-        }
-    }
-    return result;
-}
-export function deleteEdge(id) {
-    const db = getDatabase();
-    db.prepare(`DELETE FROM constellation_edges WHERE id = ?`).run(id);
-}
-export function getEdgeCountForMemory(memoryId) {
-    const db = getDatabase();
-    const row = db.prepare(`
-    SELECT COUNT(*) as count FROM constellation_edges
-    WHERE source_id = ? OR target_id = ?
-  `).get(memoryId, memoryId);
-    return row?.count ?? 0;
-}
-// ---------------------------------------------------------------------------
-// Conflict queries
-// ---------------------------------------------------------------------------
-export function createConflict(conflict) {
-    const db = getDatabase();
-    db.prepare(`
-    INSERT INTO memory_conflicts (
-      id, memory_id, conflicting_memory_id, severity,
-      description, status, resolution, project, created_at, resolved_at
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `).run(conflict.id, conflict.memory_id, conflict.conflicting_memory_id, conflict.severity, conflict.description, conflict.status, conflict.resolution ?? null, conflict.project, conflict.created_at, conflict.resolved_at ?? null);
-}
-export function getConflicts(project, status) {
-    const db = getDatabase();
-    const rows = status
-        ? db.prepare(`
-        SELECT * FROM memory_conflicts
-        WHERE project = ? AND status = ?
-        ORDER BY created_at DESC
-      `).all(project, status)
-        : db.prepare(`
-        SELECT * FROM memory_conflicts
-        WHERE project = ?
-        ORDER BY created_at DESC
-      `).all(project);
-    return rows.map((r) => deserializeConflict(r));
-}
-export function getConflictsForMemory(memoryId) {
-    const db = getDatabase();
-    const rows = db.prepare(`
-    SELECT * FROM memory_conflicts
-    WHERE memory_id = ? OR conflicting_memory_id = ?
-    ORDER BY created_at DESC
-  `).all(memoryId, memoryId);
-    return rows.map((r) => deserializeConflict(r));
-}
-export function resolveConflict(id, resolution) {
-    const db = getDatabase();
-    const now = new Date().toISOString();
-    db.prepare(`
-    UPDATE memory_conflicts
-    SET status = 'resolved', resolution = ?, resolved_at = ?
-    WHERE id = ?
-  `).run(resolution, now, id);
-}
-// ---------------------------------------------------------------------------
-// Observation queries
-// ---------------------------------------------------------------------------
-export function createObservation(entry) {
-    const db = getDatabase();
-    db.prepare(`
-    INSERT INTO observation_log (id, content, extracted_memories, source, project, created_at)
-    VALUES (?, ?, ?, ?, ?, ?)
-  `).run(entry.id, entry.content, JSON.stringify(entry.extracted_memories), entry.source, entry.project, entry.created_at);
-}
-export function getObservations(project, limit = 20) {
-    const db = getDatabase();
-    const rows = db.prepare(`
-    SELECT * FROM observation_log
-    WHERE project = ?
-    ORDER BY created_at DESC
-    LIMIT ?
-  `).all(project, limit);
-    return rows.map((r) => deserializeObservation(r));
-}
-// ---------------------------------------------------------------------------
-// Temporal queries
-// ---------------------------------------------------------------------------
-export function getMemoriesAtTime(project, timestamp) {
-    const db = getDatabase();
-    const rows = db.prepare(`
-    SELECT * FROM memories
-    WHERE project = ?
-      AND deleted_at IS NULL
-      AND (valid_from IS NULL OR valid_from <= ?)
-      AND (valid_until IS NULL OR valid_until > ?)
-    ORDER BY distance ASC
-  `).all(project, timestamp, timestamp);
-    return rows.map((r) => deserializeMemory(asRawMemory(r)));
-}
-export function supersedMemory(memoryId, newMemoryId) {
-    const db = getDatabase();
-    const now = new Date().toISOString();
-    db.prepare(`
-    UPDATE memories
-    SET superseded_by = ?, valid_until = ?, updated_at = ?
-    WHERE id = ?
-  `).run(newMemoryId, now, now, memoryId);
-}
-export function getSupersessionChain(memoryId) {
-    const db = getDatabase();
-    const chain = [];
-    let currentId = memoryId;
-    while (currentId) {
-        const row = db.prepare(`SELECT * FROM memories WHERE id = ?`).get(currentId);
-        if (!row)
-            break;
-        const mem = deserializeMemory(asRawMemory(row));
-        chain.push(mem);
-        currentId = mem.superseded_by ?? null;
-    }
-    return chain;
-}
-// ---------------------------------------------------------------------------
-// Consolidation queries
-// ---------------------------------------------------------------------------
-export function consolidateMemories(sourceIds, targetId) {
-    if (sourceIds.length === 0)
-        return;
-    const db = getDatabase();
-    const now = new Date().toISOString();
-    const placeholders = sourceIds.map(() => '?').join(', ');
-    db.prepare(`
-    UPDATE memories
-    SET consolidated_into = ?, updated_at = ?
-    WHERE id IN (${placeholders})
-  `).run(targetId, now, ...sourceIds);
-}
-export function getConsolidationHistory(memoryId) {
-    const db = getDatabase();
-    const rows = db.prepare(`
-    SELECT * FROM memories
-    WHERE consolidated_into = ?
-    ORDER BY created_at ASC
-  `).all(memoryId);
-    return rows.map((r) => deserializeMemory(asRawMemory(r)));
-}
-// ---------------------------------------------------------------------------
-// Multi-project queries
-// ---------------------------------------------------------------------------
-export function getUniversalMemories(limit = 50) {
-    const db = getDatabase();
-    const rows = db.prepare(`
-    SELECT * FROM memories
-    WHERE is_universal = 1 AND deleted_at IS NULL
-    ORDER BY importance DESC
-    LIMIT ?
-  `).all(limit);
-    return rows.map((r) => deserializeMemory(asRawMemory(r)));
-}
-export function setUniversal(memoryId, isUniversal) {
-    const db = getDatabase();
-    const now = new Date().toISOString();
-    db.prepare(`
-    UPDATE memories SET is_universal = ?, updated_at = ? WHERE id = ?
-  `).run(isUniversal ? 1 : 0, now, memoryId);
-}
-export function listProjects() {
-    const db = getDatabase();
-    const rows = db.prepare(`
-    SELECT project, COUNT(*) as count
-    FROM memories
-    WHERE deleted_at IS NULL
-    GROUP BY project
-    ORDER BY count DESC
-  `).all();
-    return rows.map((r) => {
-        const row = r;
-        return { project: row.project, count: row.count };
-    });
-}
-// ---------------------------------------------------------------------------
-// Quality queries
-// ---------------------------------------------------------------------------
-export function updateMemoryContent(id, content) {
-    const db = getDatabase();
-    const now = new Date().toISOString();
-    db.prepare(`
-    UPDATE memories SET content = ?, updated_at = ? WHERE id = ?
-  `).run(content, now, id);
-}
-export function updateQualityScore(memoryId, score) {
-    const db = getDatabase();
-    const now = new Date().toISOString();
-    db.prepare(`
-    UPDATE memories SET quality_score = ?, updated_at = ? WHERE id = ?
-  `).run(score, now, memoryId);
-}
-export function getMemoriesByQuality(project, minScore = 0.0, maxScore = 1.0) {
-    const db = getDatabase();
-    const rows = db.prepare(`
-    SELECT * FROM memories
-    WHERE project = ?
-      AND deleted_at IS NULL
-      AND quality_score >= ?
-      AND quality_score <= ?
-    ORDER BY quality_score DESC
-  `).all(project, minScore, maxScore);
-    return rows.map((r) => deserializeMemory(asRawMemory(r)));
-}
-// ---------------------------------------------------------------------------
-// Analytics queries
-// ---------------------------------------------------------------------------
-export function getTopTags(project, limit = 20) {
-    const db = getDatabase();
-    // Tags are stored as JSON arrays ??we use the memories table and parse in JS
-    const rows = db.prepare(`
-    SELECT tags FROM memories
-    WHERE project = ? AND deleted_at IS NULL
-  `).all(project);
-    const tagCounts = new Map();
-    for (const r of rows) {
-        const row = r;
-        const tags = parseJsonArray(row.tags);
-        for (const tag of tags) {
-            tagCounts.set(tag, (tagCounts.get(tag) ?? 0) + 1);
-        }
-    }
-    return [...tagCounts.entries()]
-        .map(([tag, count]) => ({ tag, count }))
-        .sort((a, b) => b.count - a.count)
-        .slice(0, limit);
-}
-export function getActivityTimeline(project, days = 30) {
-    const db = getDatabase();
-    const cutoff = new Date(Date.now() - days * 24 * 60 * 60 * 1000).toISOString().slice(0, 10);
-    const createdRows = db.prepare(`
-    SELECT date(created_at) as date, COUNT(*) as count
-    FROM memories
-    WHERE project = ? AND date(created_at) >= ?
-    GROUP BY date(created_at)
-  `).all(project, cutoff);
-    const accessedRows = db.prepare(`
-    SELECT date(last_accessed_at) as date, COUNT(*) as count
-    FROM memories
-    WHERE project = ?
-      AND last_accessed_at IS NOT NULL
-      AND date(last_accessed_at) >= ?
-    GROUP BY date(last_accessed_at)
-  `).all(project, cutoff);
-    const timeline = new Map();
-    for (const r of createdRows) {
-        const row = r;
-        const entry = timeline.get(row.date) ?? { created: 0, accessed: 0 };
-        entry.created = row.count;
-        timeline.set(row.date, entry);
-    }
-    for (const r of accessedRows) {
-        const row = r;
-        const entry = timeline.get(row.date) ?? { created: 0, accessed: 0 };
-        entry.accessed = row.count;
-        timeline.set(row.date, entry);
-    }
-    return [...timeline.entries()]
-        .map(([date, counts]) => ({ date, ...counts }))
-        .sort((a, b) => a.date.localeCompare(b.date));
-}
-export function getRecallSuccessRate(project) {
-    const db = getDatabase();
-    const result = db.prepare(`
-    SELECT
-      COUNT(*) as total,
-      SUM(CASE WHEN access_count > 0 THEN 1 ELSE 0 END) as accessed
-    FROM memories
-    WHERE project = ? AND deleted_at IS NULL
-  `).get(project);
-    const row = result;
-    if (!row || row.total === 0)
-        return 0;
-    return row.accessed / row.total;
-}
-export function getAnalytics(project) {
-    const db = getDatabase();
-    // Aggregate stats
-    const statsRow = db.prepare(`
-    SELECT
-      COUNT(*) as total_memories,
-      AVG(CASE WHEN quality_score IS NOT NULL THEN quality_score ELSE 0.5 END) as avg_quality,
-      AVG(importance) as avg_importance,
-      SUM(CASE WHEN consolidated_into IS NOT NULL THEN 1 ELSE 0 END) as consolidation_count
-    FROM memories
-    WHERE project = ? AND deleted_at IS NULL
-  `).get(project);
-    const stats = (statsRow ?? {});
-    // Zone distribution
-    const zoneRows = db.prepare(`
-    SELECT
-      CASE
-        WHEN distance < 1.0  THEN 'core'
-        WHEN distance < 5.0  THEN 'near'
-        WHEN distance < 15.0 THEN 'active'
-        WHEN distance < 40.0 THEN 'archive'
-        WHEN distance < 70.0 THEN 'fading'
-        ELSE 'forgotten'
-      END as zone,
-      COUNT(*) as count
-    FROM memories
-    WHERE project = ? AND deleted_at IS NULL
-    GROUP BY zone
-  `).all(project);
-    const zone_distribution = {};
-    for (const r of zoneRows) {
-        const row = r;
-        zone_distribution[row.zone] = row.count;
-    }
-    // Type distribution
-    const typeRows = db.prepare(`
-    SELECT type, COUNT(*) as count
-    FROM memories
-    WHERE project = ? AND deleted_at IS NULL
-    GROUP BY type
-  `).all(project);
-    const type_distribution = {};
-    for (const r of typeRows) {
-        const row = r;
-        type_distribution[row.type] = row.count;
-    }
-    // Conflict count
-    const conflictRow = db.prepare(`
-    SELECT COUNT(*) as count FROM memory_conflicts
-    WHERE project = ? AND status = 'open'
-  `).get(project);
-    const conflict_count = (conflictRow?.count) ?? 0;
-    // Activity timeline (last 30 days)
-    const timelineRows = getActivityTimeline(project, 30);
-    const activity_timeline = timelineRows.map((row) => ({
-        date: row.date,
-        created: row.created,
-        accessed: row.accessed,
-        forgotten: 0, // soft-delete count per day ??simplified to 0 here
-    }));
-    return {
-        total_memories: stats.total_memories ?? 0,
-        zone_distribution,
-        type_distribution,
-        avg_quality: stats.avg_quality ?? 0.5,
-        avg_importance: stats.avg_importance ?? 0.5,
-        recall_success_rate: getRecallSuccessRate(project),
-        consolidation_count: stats.consolidation_count ?? 0,
-        conflict_count,
-        top_tags: getTopTags(project),
-        activity_timeline,
-    };
-}
+export * from './queries/shared.js';
+export * from './queries/memory-queries.js';
+export * from './queries/sun-queries.js';
+export * from './queries/orbit-queries.js';
+export * from './queries/constellation-queries.js';
+export * from './queries/conflict-queries.js';
+export * from './queries/temporal-queries.js';
+export * from './queries/analytics-queries.js';
+export * from './queries/observation-queries.js';
+export * from './queries/datasource-queries.js';
 //# sourceMappingURL=queries.js.map