@dahch/muninn 0.0.0-stage → 0.1.0

package/dist/service/memory-service.js

@@ -0,0 +1,891 @@
+import fs from "node:fs";
+import path from "node:path";
+import crypto from "node:crypto";
+import { assertDocPath } from "../util/path-safety.js";
+import { getDatabase, ensureProject, findGitRoot, } from "../db/client.js";
+export const VALID_CATEGORIES = [
+    "decision",
+    "convention",
+    "discovery",
+    "bugfix",
+    "architecture",
+];
+export const VALID_ENTITY_TYPES = [
+    "file",
+    "function",
+    "class",
+    "interface",
+    "module",
+];
+/**
+ * Normalizes input symbols into canonical identifier, filePath, and entityType.
+ */
+export function normalizeSymbol(symbol) {
+    if (!symbol || (typeof symbol !== "string" && typeof symbol !== "object")) {
+        return { identifier: "unknown", filePath: "unknown", entityType: "module" };
+    }
+    if (typeof symbol === "string") {
+        const raw = symbol.trim();
+        if (!raw) {
+            return { identifier: "unknown", filePath: "unknown", entityType: "module" };
+        }
+        if (raw.includes("::")) {
+            const parts = raw.split("::");
+            const filePath = parts[0] || "unknown";
+            return {
+                identifier: raw,
+                filePath,
+                entityType: "module",
+            };
+        }
+        if (raw.includes("/") ||
+            raw.endsWith(".ts") ||
+            raw.endsWith(".js") ||
+            raw.endsWith(".json")) {
+            return {
+                identifier: raw,
+                filePath: raw,
+                entityType: "file",
+            };
+        }
+        return {
+            identifier: raw,
+            filePath: "unknown",
+            entityType: "module",
+        };
+    }
+    const rawName = symbol.name?.trim();
+    const rawFilePath = (symbol.filePath ?? symbol.file_path)?.trim();
+    const rawIdentifier = symbol.identifier?.trim();
+    const rawType = (symbol.type ?? symbol.entity_type);
+    let identifier;
+    if (rawIdentifier) {
+        identifier = rawIdentifier;
+    }
+    else if (rawFilePath) {
+        identifier =
+            rawName && rawName !== "default"
+                ? `${rawFilePath}::${rawName}`
+                : rawFilePath;
+    }
+    else if (rawName) {
+        identifier = rawName;
+    }
+    else {
+        identifier = "unknown";
+    }
+    let filePath;
+    if (rawFilePath) {
+        filePath = rawFilePath;
+    }
+    else if (rawIdentifier && rawIdentifier.includes("::")) {
+        filePath = rawIdentifier.split("::")[0] || "unknown";
+    }
+    else if (rawIdentifier &&
+        (rawIdentifier.includes("/") ||
+            rawIdentifier.endsWith(".ts") ||
+            rawIdentifier.endsWith(".js") ||
+            rawIdentifier.endsWith(".json"))) {
+        filePath = rawIdentifier;
+    }
+    else {
+        filePath = "unknown";
+    }
+    let entityType = "module";
+    if (rawType && VALID_ENTITY_TYPES.includes(rawType)) {
+        entityType = rawType;
+    }
+    else if (rawFilePath && (!rawName || rawName === "default")) {
+        entityType = "file";
+    }
+    return {
+        identifier,
+        filePath,
+        entityType,
+    };
+}
+/**
+ * Safely format query terms for SQLite FTS5 syntax.
+ * Escapes special characters, wraps terms in quotes, and safely supports prefix queries.
+ * Returns an empty string if no valid search terms remain.
+ */
+export function sanitizeFtsQuery(query) {
+    if (!query || typeof query !== "string") {
+        return "";
+    }
+    const trimmed = query.trim();
+    if (!trimmed) {
+        return "";
+    }
+    // Regex to extract double-quoted phrases OR non-whitespace words
+    const tokenRegex = /"([^"]*)"|(\S+)/g;
+    const terms = [];
+    let match;
+    while ((match = tokenRegex.exec(trimmed)) !== null) {
+        if (match[1] !== undefined) {
+            // It was inside double quotes
+            const inner = match[1].replace(/"/g, "").trim();
+            if (inner && /[\p{L}\p{N}]/u.test(inner)) {
+                terms.push(`"${inner}"`);
+            }
+        }
+        else if (match[2] !== undefined) {
+            const raw = match[2].trim();
+            const cleaned = raw.replace(/"/g, "");
+            if (!cleaned) {
+                continue;
+            }
+            // Check if ends with wildcard *
+            if (cleaned.endsWith("*") && cleaned.length > 1) {
+                const base = cleaned.slice(0, -1);
+                if (/[\p{L}\p{N}]/u.test(base)) {
+                    terms.push(`"${base}"*`);
+                    continue;
+                }
+            }
+            // Check if contains letters or numbers
+            if (/[\p{L}\p{N}]/u.test(cleaned)) {
+                terms.push(`"${cleaned}"`);
+            }
+        }
+    }
+    return terms.join(" ");
+}
+export class MemoryService {
+    _db;
+    _currentProject;
+    isDbOwned;
+    constructor(options) {
+        if (options?.db) {
+            this._db = options.db;
+            this.isDbOwned = false;
+        }
+        else {
+            // ONE root for both (ADR-49): the database file and the project record are
+            // resolved from `projectRoot`, so `--project X` can never label a row in
+            // another project's database.
+            this._db = getDatabase(options?.dbPath, options?.projectRoot);
+            this.isDbOwned = true;
+        }
+        try {
+            this._currentProject = ensureProject(this._db, {
+                rootPath: options?.projectRoot,
+                startDir: options?.projectRoot,
+            });
+        }
+        catch (err) {
+            if (this.isDbOwned && this._db?.open) {
+                this._db.close();
+            }
+            throw err;
+        }
+    }
+    get db() {
+        return this._db;
+    }
+    get currentProject() {
+        return this._currentProject;
+    }
+    /**
+     * Screen the durable JSONL export path exactly like the database path
+     * (SEC-006): a `.huginn/memories.jsonl` a cloned repository ships as a symlink
+     * must be neither written through nor read from — either direction would move
+     * project content outside the project (or pull foreign content in, where the
+     * MCP memory tools would serve it to the agent).
+     */
+    assertMemoryPath(resolvedPath, action) {
+        const root = this._currentProject.root_path || findGitRoot() || process.cwd();
+        assertDocPath(resolvedPath, {
+            projectPath: root,
+            label: "the Muninn memory export",
+            action,
+        });
+    }
+    /**
+     * Closes the database connection if managed internally by the service.
+     */
+    close(force = false) {
+        if ((this.isDbOwned || force) && this._db.open) {
+            this._db.close();
+        }
+    }
+    /**
+     * Saves an observation and transactionally links any provided symbols.
+     */
+    saveObservation(input) {
+        const category = input.category;
+        if (!VALID_CATEGORIES.includes(category)) {
+            throw new Error(`Invalid category "${input.category}". Allowed categories: ${VALID_CATEGORIES.join(", ")}`);
+        }
+        if (!input.title || typeof input.title !== "string" || !input.title.trim()) {
+            throw new Error("Observation title is required and cannot be empty");
+        }
+        if (input.content === undefined ||
+            input.content === null ||
+            typeof input.content !== "string") {
+            throw new Error("Observation content is required");
+        }
+        const projectId = input.projectId ?? input.project_id ?? this._currentProject.id;
+        const topicKey = input.topicKey !== undefined
+            ? input.topicKey
+            : (input.topic_key ?? null);
+        const observationId = crypto.randomUUID();
+        return this._db.transaction(() => {
+            this._db
+                .prepare(`INSERT INTO observations (id, project_id, category, title, content, topic_key)
+           VALUES (?, ?, ?, ?, ?, ?)`)
+                .run(observationId, projectId, category, input.title.trim(), input.content, topicKey);
+            const symbols = input.symbols ?? [];
+            const selectEntityStmt = this._db.prepare(`SELECT id, project_id, entity_type, identifier, file_path
+         FROM entities
+         WHERE project_id = ? AND identifier = ?`);
+            const insertEntityStmt = this._db.prepare(`INSERT INTO entities (id, project_id, entity_type, identifier, file_path)
+         VALUES (?, ?, ?, ?, ?)`);
+            const linkStmt = this._db.prepare(`INSERT OR IGNORE INTO observation_entities (observation_id, entity_id)
+         VALUES (?, ?)`);
+            for (const sym of symbols) {
+                const norm = normalizeSymbol(sym);
+                let entity = selectEntityStmt.get(projectId, norm.identifier);
+                if (!entity) {
+                    const entityId = crypto.randomUUID();
+                    insertEntityStmt.run(entityId, projectId, norm.entityType, norm.identifier, norm.filePath);
+                    entity = {
+                        id: entityId,
+                        project_id: projectId,
+                        entity_type: norm.entityType,
+                        identifier: norm.identifier,
+                        file_path: norm.filePath,
+                    };
+                }
+                linkStmt.run(observationId, entity.id);
+            }
+            const observation = this._db
+                .prepare(`SELECT id, project_id, category, title, content, topic_key, created_at, updated_at
+           FROM observations
+           WHERE id = ?`)
+                .get(observationId);
+            if (!observation) {
+                throw new Error(`Failed to retrieve newly created observation: ${observationId}`);
+            }
+            const entities = this._db
+                .prepare(`SELECT e.id, e.project_id, e.entity_type, e.identifier, e.file_path
+           FROM entities e
+           JOIN observation_entities oe ON oe.entity_id = e.id
+           WHERE oe.observation_id = ?
+           ORDER BY e.identifier ASC`)
+                .all(observationId);
+            return {
+                ...observation,
+                entities,
+            };
+        })();
+    }
+    /**
+     * Retrieves linked entities for observation IDs in chunks of at most 500
+     * to prevent exceeding SQLite parameter bounds.
+     */
+    _fetchEntitiesForObservations(obsIds) {
+        const entityMap = new Map();
+        if (obsIds.length === 0) {
+            return entityMap;
+        }
+        const CHUNK_SIZE = 500;
+        for (let i = 0; i < obsIds.length; i += CHUNK_SIZE) {
+            const chunk = obsIds.slice(i, i + CHUNK_SIZE);
+            const placeholders = chunk.map(() => "?").join(",");
+            const entityRows = this._db
+                .prepare(`SELECT e.id, e.project_id, e.entity_type, e.identifier, e.file_path, oe.observation_id
+           FROM entities e
+           JOIN observation_entities oe ON oe.entity_id = e.id
+           WHERE oe.observation_id IN (${placeholders})
+           ORDER BY e.identifier ASC`)
+                .all(...chunk);
+            for (const row of entityRows) {
+                let list = entityMap.get(row.observation_id);
+                if (!list) {
+                    list = [];
+                    entityMap.set(row.observation_id, list);
+                }
+                list.push({
+                    id: row.id,
+                    project_id: row.project_id,
+                    entity_type: row.entity_type,
+                    identifier: row.identifier,
+                    file_path: row.file_path,
+                });
+            }
+        }
+        return entityMap;
+    }
+    /**
+     * Searches observations using FTS5 BM25 relevance ranking.
+     * Query terms are safely sanitized, rank ordering is ASC (lower BM25 = higher relevance),
+     * and linked entities are attached to each result.
+     */
+    search(options) {
+        if (!options || !options.query) {
+            return [];
+        }
+        const sanitized = sanitizeFtsQuery(options.query);
+        if (!sanitized) {
+            return [];
+        }
+        const conditions = ["observations_fts MATCH ?"];
+        const params = [sanitized];
+        if (options.category) {
+            conditions.push("o.category = ?");
+            params.push(options.category);
+        }
+        if (!options?.allProjects) {
+            const explicitProjectId = options?.projectId !== undefined
+                ? options.projectId
+                : options?.project_id;
+            const targetProjectId = explicitProjectId !== undefined
+                ? explicitProjectId
+                : this._currentProject.id;
+            if (targetProjectId) {
+                conditions.push("o.project_id = ?");
+                params.push(targetProjectId);
+            }
+        }
+        const parsedLimit = typeof options?.limit === "number" && Number.isFinite(options.limit)
+            ? options.limit
+            : 10;
+        const limit = Math.min(Math.max(1, parsedLimit), 500);
+        params.push(limit);
+        const sql = `
+      SELECT
+        o.id,
+        o.project_id,
+        o.category,
+        o.title,
+        o.content,
+        o.topic_key,
+        o.created_at,
+        o.updated_at,
+        bm25(observations_fts) AS rank
+      FROM observations_fts
+      JOIN observations o ON o.rowid = observations_fts.rowid
+      WHERE ${conditions.join(" AND ")}
+      ORDER BY rank ASC
+      LIMIT ?
+    `;
+        let rows;
+        try {
+            rows = this._db.prepare(sql).all(...params);
+        }
+        catch (err) {
+            const code = typeof err === "object" && err !== null && "code" in err
+                ? String(err.code)
+                : "";
+            const message = err instanceof Error ? err.message : String(err);
+            const isFatal = code.startsWith("SQLITE_IOERR") ||
+                code.startsWith("SQLITE_CORRUPT") ||
+                code === "SQLITE_NOTADB" ||
+                code === "SQLITE_FULL" ||
+                code === "SQLITE_CANTOPEN" ||
+                /disk i\/o|corrupt|not a database|disk is full/i.test(message);
+            if (isFatal) {
+                console.error("Fatal SQLite error during search query:", err);
+                throw err;
+            }
+            console.warn("FTS search query execution failed:", message);
+            return [];
+        }
+        if (rows.length === 0) {
+            return [];
+        }
+        const obsIds = rows.map((r) => r.id);
+        const entityMap = this._fetchEntitiesForObservations(obsIds);
+        return rows.map((r) => ({
+            id: r.id,
+            project_id: r.project_id,
+            category: r.category,
+            title: r.title,
+            content: r.content,
+            topic_key: r.topic_key,
+            created_at: r.created_at,
+            updated_at: r.updated_at,
+            rank: r.rank,
+            entities: entityMap.get(r.id) ?? [],
+        }));
+    }
+    /**
+     * Retrieves recent observations ordered by updated_at DESC, created_at DESC.
+     */
+    getContext(options) {
+        const conditions = [];
+        const params = [];
+        if (options?.category) {
+            conditions.push("category = ?");
+            params.push(options.category);
+        }
+        const topicKey = options?.topicKey !== undefined ? options.topicKey : options?.topic_key;
+        if (topicKey !== undefined && topicKey !== null) {
+            conditions.push("topic_key = ?");
+            params.push(topicKey);
+        }
+        if (!options?.allProjects) {
+            const explicitProjectId = options?.projectId !== undefined
+                ? options.projectId
+                : options?.project_id;
+            const targetProjectId = explicitProjectId !== undefined
+                ? explicitProjectId
+                : this._currentProject.id;
+            if (targetProjectId) {
+                conditions.push("project_id = ?");
+                params.push(targetProjectId);
+            }
+        }
+        const whereClause = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+        const parsedLimit = typeof options?.limit === "number" && Number.isFinite(options.limit)
+            ? options.limit
+            : 20;
+        const limit = Math.min(Math.max(1, parsedLimit), 500);
+        params.push(limit);
+        const sql = `
+      SELECT id, project_id, category, title, content, topic_key, created_at, updated_at
+      FROM observations
+      ${whereClause}
+      ORDER BY updated_at DESC, created_at DESC
+      LIMIT ?
+    `;
+        const rows = this._db.prepare(sql).all(...params);
+        if (rows.length === 0) {
+            return [];
+        }
+        const obsIds = rows.map((r) => r.id);
+        const entityMap = this._fetchEntitiesForObservations(obsIds);
+        return rows.map((r) => ({
+            id: r.id,
+            project_id: r.project_id,
+            category: r.category,
+            title: r.title,
+            content: r.content,
+            topic_key: r.topic_key,
+            created_at: r.created_at,
+            updated_at: r.updated_at,
+            entities: entityMap.get(r.id) ?? [],
+        }));
+    }
+    /**
+     * Transactionally links an entity to an observation.
+     */
+    linkSymbol(inputOrObsId, symbolArg) {
+        let observationId;
+        let symbol;
+        if (typeof inputOrObsId === "string") {
+            observationId = inputOrObsId;
+            if (!symbolArg) {
+                throw new Error("Symbol must be provided to linkSymbol");
+            }
+            symbol = symbolArg;
+        }
+        else {
+            observationId =
+                inputOrObsId.observationId ??
+                    inputOrObsId.observation_id;
+            symbol = inputOrObsId.symbol;
+        }
+        if (!observationId) {
+            throw new Error("observationId is required for linkSymbol");
+        }
+        if (!symbol) {
+            throw new Error("symbol is required for linkSymbol");
+        }
+        const observation = this._db
+            .prepare(`SELECT id, project_id, category, title, content, topic_key, created_at, updated_at
+         FROM observations
+         WHERE id = ?`)
+            .get(observationId);
+        if (!observation) {
+            throw new Error(`Observation with id "${observationId}" not found`);
+        }
+        const projectId = observation.project_id;
+        const norm = normalizeSymbol(symbol);
+        return this._db.transaction(() => {
+            let entity = this._db
+                .prepare(`SELECT id, project_id, entity_type, identifier, file_path
+           FROM entities
+           WHERE project_id = ? AND identifier = ?`)
+                .get(projectId, norm.identifier);
+            if (!entity) {
+                const entityId = crypto.randomUUID();
+                this._db
+                    .prepare(`INSERT INTO entities (id, project_id, entity_type, identifier, file_path)
+             VALUES (?, ?, ?, ?, ?)`)
+                    .run(entityId, projectId, norm.entityType, norm.identifier, norm.filePath);
+                entity = {
+                    id: entityId,
+                    project_id: projectId,
+                    entity_type: norm.entityType,
+                    identifier: norm.identifier,
+                    file_path: norm.filePath,
+                };
+            }
+            this._db
+                .prepare(`INSERT OR IGNORE INTO observation_entities (observation_id, entity_id)
+           VALUES (?, ?)`)
+                .run(observationId, entity.id);
+            return {
+                observation,
+                entity,
+            };
+        })();
+    }
+    /**
+     * Escapes LIKE pattern special characters (%, _, \)
+     */
+    _escapeLikePattern(str) {
+        return str.replace(/[\\%_]/g, "\\$&");
+    }
+    /**
+     * Inspects a symbol in Muninn memory, returning its entity metadata,
+     * incoming and outgoing dependencies, and linked observations.
+     */
+    inspectSymbol(symbol, projectId) {
+        if (!symbol || typeof symbol !== "string" || !symbol.trim()) {
+            return null;
+        }
+        const targetProjectId = projectId ?? this._currentProject.id;
+        const query = symbol.trim();
+        // 1. Try exact match
+        let entity = this._db
+            .prepare(`SELECT id, project_id, entity_type, identifier, file_path
+         FROM entities
+         WHERE project_id = ? AND identifier = ?`)
+            .get(targetProjectId, query);
+        const escapedQuery = this._escapeLikePattern(query);
+        // 2. Try suffix match (e.g. searching 'run' matches 'src/app.ts::run', or 'login' matches 'src/auth.ts::AuthManager.login')
+        // Supports matching class methods with canonical format <relPath>::<ClassName>.<methodName> (REV-005, REV-008, SEC-004)
+        if (!entity) {
+            entity = this._db
+                .prepare(`SELECT id, project_id, entity_type, identifier, file_path
+           FROM entities
+           WHERE project_id = ? AND (identifier LIKE '%::' || ? ESCAPE '\\' OR identifier LIKE '%.' || ? ESCAPE '\\')
+           ORDER BY identifier ASC
+           LIMIT 1`)
+                .get(targetProjectId, escapedQuery, escapedQuery);
+        }
+        // 3. Try prefix match or file_path match
+        if (!entity) {
+            entity = this._db
+                .prepare(`SELECT id, project_id, entity_type, identifier, file_path
+           FROM entities
+           WHERE project_id = ? AND (identifier LIKE ? || '%' ESCAPE '\\' OR file_path = ?)
+           ORDER BY identifier ASC
+           LIMIT 1`)
+                .get(targetProjectId, escapedQuery, query);
+        }
+        if (!entity) {
+            return null;
+        }
+        const outgoingRows = this._db
+            .prepare(`SELECT e.id, e.project_id, e.entity_type, e.identifier, e.file_path, ed.relation_type
+         FROM entity_dependencies ed
+         JOIN entities e ON e.id = ed.target_entity_id
+         WHERE ed.source_entity_id = ?
+         ORDER BY e.identifier ASC`)
+            .all(entity.id);
+        const outgoing = outgoingRows.map((r) => ({
+            entity: {
+                id: r.id,
+                project_id: r.project_id,
+                entity_type: r.entity_type,
+                identifier: r.identifier,
+                file_path: r.file_path,
+            },
+            relationType: r.relation_type,
+        }));
+        // Fetch incoming dependencies
+        const incomingRows = this._db
+            .prepare(`SELECT e.id, e.project_id, e.entity_type, e.identifier, e.file_path, ed.relation_type
+         FROM entity_dependencies ed
+         JOIN entities e ON e.id = ed.source_entity_id
+         WHERE ed.target_entity_id = ?
+         ORDER BY e.identifier ASC`)
+            .all(entity.id);
+        const incoming = incomingRows.map((r) => ({
+            entity: {
+                id: r.id,
+                project_id: r.project_id,
+                entity_type: r.entity_type,
+                identifier: r.identifier,
+                file_path: r.file_path,
+            },
+            relationType: r.relation_type,
+        }));
+        // Fetch linked observations
+        const observations = this._db
+            .prepare(`SELECT o.id, o.project_id, o.category, o.title, o.content, o.topic_key, o.created_at, o.updated_at
+         FROM observations o
+         JOIN observation_entities oe ON oe.observation_id = o.id
+         WHERE oe.entity_id = ?
+         ORDER BY o.updated_at DESC, o.created_at DESC`)
+            .all(entity.id);
+        return {
+            entity,
+            dependencies: {
+                outgoing,
+                incoming,
+            },
+            observations,
+        };
+    }
+    /**
+     * Retrieves aggregate counts of projects, observations, entities, and links.
+     */
+    getStats(projectId) {
+        if (projectId) {
+            const pCount = this._db
+                .prepare("SELECT COUNT(*) as count FROM projects WHERE id = ?")
+                .get(projectId)?.count ?? 0;
+            const oCount = this._db
+                .prepare("SELECT COUNT(*) as count FROM observations WHERE project_id = ?")
+                .get(projectId)?.count ?? 0;
+            const eCount = this._db
+                .prepare("SELECT COUNT(*) as count FROM entities WHERE project_id = ?")
+                .get(projectId)?.count ?? 0;
+            const lCount = this._db
+                .prepare(`SELECT COUNT(*) as count
+             FROM observation_entities oe
+             JOIN observations o ON o.id = oe.observation_id
+             WHERE o.project_id = ?`)
+                .get(projectId)?.count ?? 0;
+            return {
+                projects: pCount,
+                observations: oCount,
+                entities: eCount,
+                links: lCount,
+            };
+        }
+        const pCount = this._db
+            .prepare("SELECT COUNT(*) as count FROM projects")
+            .get()?.count ?? 0;
+        const oCount = this._db
+            .prepare("SELECT COUNT(*) as count FROM observations")
+            .get()?.count ?? 0;
+        const eCount = this._db
+            .prepare("SELECT COUNT(*) as count FROM entities")
+            .get()?.count ?? 0;
+        const lCount = this._db
+            .prepare("SELECT COUNT(*) as count FROM observation_entities")
+            .get()?.count ?? 0;
+        return {
+            projects: pCount,
+            observations: oCount,
+            entities: eCount,
+            links: lCount,
+        };
+    }
+    syncToDisk(targetPathOrOptions, optionsArg) {
+        let targetPath;
+        let options;
+        if (typeof targetPathOrOptions === "object" && targetPathOrOptions !== null) {
+            options = targetPathOrOptions;
+            targetPath = undefined;
+        }
+        else {
+            targetPath = targetPathOrOptions;
+            options = optionsArg;
+        }
+        let resolvedPath;
+        if (targetPath) {
+            if (path.isAbsolute(targetPath)) {
+                resolvedPath = path.resolve(targetPath);
+            }
+            else {
+                const root = this._currentProject.root_path || findGitRoot() || process.cwd();
+                resolvedPath = path.resolve(root, targetPath);
+            }
+        }
+        else {
+            const root = this._currentProject.root_path || findGitRoot() || process.cwd();
+            resolvedPath = path.join(root, ".huginn", "memories.jsonl");
+        }
+        this.assertMemoryPath(resolvedPath, "write");
+        const dir = path.dirname(resolvedPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+        }
+        const targetProjectId = options?.projectId ?? this._currentProject.id;
+        let observations;
+        let entityRows;
+        if (options?.allProjects === true) {
+            observations = this._db
+                .prepare(`SELECT id, project_id, category, title, content, topic_key, created_at, updated_at
+           FROM observations
+           ORDER BY created_at ASC`)
+                .all();
+            entityRows = this._db
+                .prepare(`SELECT e.id, e.project_id, e.entity_type, e.identifier, e.file_path, oe.observation_id
+           FROM entities e
+           JOIN observation_entities oe ON oe.entity_id = e.id
+           ORDER BY e.identifier ASC`)
+                .all();
+        }
+        else {
+            observations = this._db
+                .prepare(`SELECT id, project_id, category, title, content, topic_key, created_at, updated_at
+           FROM observations
+           WHERE project_id = ?
+           ORDER BY created_at ASC`)
+                .all(targetProjectId);
+            entityRows = this._db
+                .prepare(`SELECT e.id, e.project_id, e.entity_type, e.identifier, e.file_path, oe.observation_id
+           FROM entities e
+           JOIN observation_entities oe ON oe.entity_id = e.id
+           JOIN observations o ON o.id = oe.observation_id
+           WHERE o.project_id = ?
+           ORDER BY e.identifier ASC`)
+                .all(targetProjectId);
+        }
+        const entityMap = new Map();
+        for (const row of entityRows) {
+            let list = entityMap.get(row.observation_id);
+            if (!list) {
+                list = [];
+                entityMap.set(row.observation_id, list);
+            }
+            list.push({
+                id: row.id,
+                project_id: row.project_id,
+                entity_type: row.entity_type,
+                identifier: row.identifier,
+                file_path: row.file_path,
+            });
+        }
+        const lines = observations.map((obs) => {
+            const record = {
+                ...obs,
+                entities: entityMap.get(obs.id) ?? [],
+            };
+            return JSON.stringify(record);
+        });
+        const tmpPath = `${resolvedPath}.tmp`;
+        try {
+            fs.writeFileSync(tmpPath, lines.length > 0 ? lines.join("\n") + "\n" : "", { encoding: "utf-8", mode: 0o600 });
+            try {
+                fs.chmodSync(tmpPath, 0o600);
+            }
+            catch {
+                // ignore on platforms where chmod fails
+            }
+            fs.renameSync(tmpPath, resolvedPath);
+        }
+        catch (err) {
+            if (fs.existsSync(tmpPath)) {
+                try {
+                    fs.unlinkSync(tmpPath);
+                }
+                catch {
+                    // ignore cleanup error
+                }
+            }
+            throw err;
+        }
+        return {
+            path: resolvedPath,
+            count: observations.length,
+        };
+    }
+    /**
+     * Reads a JSON Lines (.jsonl) file and idempotently imports records into the database.
+     */
+    importFromDisk(sourcePath) {
+        let resolvedPath;
+        if (sourcePath) {
+            if (path.isAbsolute(sourcePath)) {
+                resolvedPath = path.resolve(sourcePath);
+            }
+            else {
+                const root = this._currentProject.root_path || findGitRoot() || process.cwd();
+                resolvedPath = path.resolve(root, sourcePath);
+            }
+        }
+        else {
+            const root = this._currentProject.root_path || findGitRoot() || process.cwd();
+            resolvedPath = path.join(root, ".huginn", "memories.jsonl");
+        }
+        this.assertMemoryPath(resolvedPath, "read");
+        if (!fs.existsSync(resolvedPath)) {
+            return { imported: 0, skipped: 0 };
+        }
+        const content = fs.readFileSync(resolvedPath, "utf-8");
+        const rawLines = content
+            .split("\n")
+            .map((l) => l.trim())
+            .filter(Boolean);
+        let imported = 0;
+        let skipped = 0;
+        const importTx = this._db.transaction(() => {
+            const checkObsStmt = this._db.prepare("SELECT id FROM observations WHERE id = ?");
+            const checkProjStmt = this._db.prepare("SELECT id FROM projects WHERE id = ?");
+            const insertObsStmt = this._db.prepare(`INSERT INTO observations (id, project_id, category, title, content, topic_key, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
+            const findEntityStmt = this._db.prepare(`SELECT id, project_id, entity_type, identifier, file_path
+         FROM entities
+         WHERE project_id = ? AND identifier = ?`);
+            const insertEntityStmt = this._db.prepare(`INSERT INTO entities (id, project_id, entity_type, identifier, file_path)
+         VALUES (?, ?, ?, ?, ?)`);
+            const linkStmt = this._db.prepare(`INSERT OR IGNORE INTO observation_entities (observation_id, entity_id)
+         VALUES (?, ?)`);
+            for (const line of rawLines) {
+                let record;
+                try {
+                    record = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                if (!record ||
+                    typeof record !== "object" ||
+                    !(typeof record.id === "string" &&
+                        typeof record.title === "string" &&
+                        typeof record.content === "string") ||
+                    !record.id.trim() ||
+                    !record.title.trim()) {
+                    continue;
+                }
+                const existing = checkObsStmt.get(record.id);
+                if (existing) {
+                    skipped++;
+                    continue;
+                }
+                let projectId = record.project_id ?? record.projectId;
+                if (!projectId || !checkProjStmt.get(projectId)) {
+                    projectId = this._currentProject.id;
+                }
+                const category = VALID_CATEGORIES.includes(record.category)
+                    ? record.category
+                    : "decision";
+                const topicKey = record.topic_key !== undefined
+                    ? record.topic_key
+                    : (record.topicKey ?? null);
+                const createdAt = record.created_at ?? new Date().toISOString();
+                const updatedAt = record.updated_at ?? createdAt;
+                insertObsStmt.run(record.id, projectId, category, record.title, record.content, topicKey, createdAt, updatedAt);
+                const symbols = record.entities ?? record.symbols ?? [];
+                if (Array.isArray(symbols)) {
+                    for (const sym of symbols) {
+                        const norm = normalizeSymbol(sym);
+                        let entity = findEntityStmt.get(projectId, norm.identifier);
+                        let entityId;
+                        if (entity) {
+                            entityId = entity.id;
+                        }
+                        else {
+                            entityId = sym.id ?? crypto.randomUUID();
+                            insertEntityStmt.run(entityId, projectId, norm.entityType, norm.identifier, norm.filePath);
+                        }
+                        linkStmt.run(record.id, entityId);
+                    }
+                }
+                imported++;
+            }
+        });
+        importTx();
+        return { imported, skipped };
+    }
+}
+//# sourceMappingURL=memory-service.js.map