hmem-mcp 6.3.1 → 6.3.2

package/dist/hmem-store.js

@@ -31,6 +31,20 @@ import os from "node:os";
 import path from "node:path";
 import { DEFAULT_CONFIG, DEFAULT_PREFIX_DESCRIPTIONS } from "./hmem-config.js";
 import { readSessionMarker, writeSessionMarker } from "./session-state.js";
+/**
+ * Thrown by write_memory when similar existing entries are detected.
+ * Handled specially by callers — surfaced as a non-error hint so the
+ * agent can decide whether to append to an existing entry or retry with
+ * force=true, without the UI flagging it in red.
+ */
+export class SimilarEntriesError extends Error {
+    bestMatch;
+    constructor(message, bestMatch) {
+        super(message);
+        this.name = "SimilarEntriesError";
+        this.bestMatch = bestMatch;
+    }
+}
 // Prefixes are now loaded from config — see this.cfg.prefixes
 // (limits are now instance-level via this.cfg.maxCharsPerLevel)
 const SCHEMA = `
@@ -270,7 +284,10 @@ export class HmemStore {
             throw new Error("Tags are required. Provide at least 1 tag (3+ recommended) for discoverability. Example: tags=['#hmem', '#sqlite', '#bug']");
         }
         const validatedTags = this.validateTags(tags);
-        // Duplicate detection: check for existing entries with significant tag overlap
+        // Duplicate detection: check for existing entries with significant tag overlap.
+        // Threshold: require at least 3 shared tags for a tag-only match — project/framework
+        // tags alone (2 overlapping generic tags like #python+#bug) are not enough to block
+        // a new entry. See issue #12.
         if (prefix !== "O" && !force) { // O-entries are auto-generated, skip check
             const tagPlaceholders = validatedTags.map(() => "?").join(", ");
             const overlapRows = this.db.prepare(`
@@ -290,7 +307,7 @@ export class HmemStore {
           AND m.obsolete != 1
           AND m.irrelevant != 1
         GROUP BY root_id
-        HAVING shared >= 2
+        HAVING shared >= 3
         ORDER BY shared DESC
         LIMIT 3
       `).all(...validatedTags, prefix);
@@ -336,9 +353,9 @@ export class HmemStore {
                     parts.push(`Similar titles:\n${ftsHits}`);
                 }
                 const bestMatch = overlapRows[0]?.root_id ?? ftsMatches[0]?.root_id;
-                throw new Error(`Similar ${prefix}-entries already exist:\n${parts.join("\n")}\n\n` +
+                throw new SimilarEntriesError(`Similar ${prefix}-entries already exist:\n${parts.join("\n")}\n\n` +
                     `If this belongs to an existing entry, use: append_memory(id="${bestMatch}", content="...")\n` +
-                    `If this is intentionally a NEW entry, retry with: force=true`);
+                    `If this is intentionally a NEW entry, retry with: force=true`, bestMatch);
             }
         }
         // Run in a transaction
@@ -3162,20 +3179,7 @@ export class HmemStore {
             }
             catch { /* malformed JSON — skip */ }
         }
-        // Scan memory_nodes.links
-        const nodeRows = this.db.prepare("SELECT id, links FROM memory_nodes WHERE links IS NOT NULL AND links LIKE ?").all(`%"${obsoleteId}"%`);
-        for (const row of nodeRows) {
-            try {
-                const arr = JSON.parse(row.links);
-                if (!arr.includes(obsoleteId))
-                    continue;
-                const updated = arr.map(l => l === obsoleteId ? correctionId : l);
-                const deduped = [...new Set(updated)];
-                this.db.prepare("UPDATE memory_nodes SET links = ? WHERE id = ?")
-                    .run(JSON.stringify(deduped), row.id);
-            }
-            catch { /* malformed JSON — skip */ }
-        }
+        // memory_nodes has no `links` column — only root entries (memories) carry links.
     }
     /** Fetch direct children of a node (root or compound), including their grandchild counts. */
     /** Bulk-fetch direct child counts for multiple parent IDs in one query. */
@@ -4112,25 +4116,6 @@ export class HmemStore {
         return { moved: subtree.length, newId: newSourceId, idMap: Object.fromEntries(idMap) };
     }
 }
-// ---- Convenience: resolve .hmem path for an agent ----
-/**
- * @deprecated Use resolveHmemPath() (no args) instead. Will be removed in v7.0.
- */
-export function resolveHmemPathLegacy(projectDir, templateName) {
-    console.error("[hmem] DEPRECATED: resolveHmemPathLegacy(projectDir, templateName) — use HMEM_PATH env var instead");
-    // No agent name configured → use memory.hmem directly in project root
-    if (!templateName || templateName === "UNKNOWN") {
-        return path.join(projectDir, "memory.hmem");
-    }
-    // Named agent → Agents/NAME/NAME.hmem (check Assistenten/ as fallback)
-    let agentDir = path.join(projectDir, "Agents", templateName);
-    if (!fs.existsSync(agentDir)) {
-        const alt = path.join(projectDir, "Assistenten", templateName);
-        if (fs.existsSync(alt))
-            agentDir = alt;
-    }
-    return path.join(agentDir, `${templateName}.hmem`);
-}
 /**
  * Resolve the path to the personal .hmem database file.
  * Priority: HMEM_PATH env var > CWD discovery > ~/.hmem/memory.hmem
@@ -4186,14 +4171,6 @@ export function resolveHmemPath(cwdOverride) {
     // Priority 4: default fallback
     return path.resolve(safeHomedir(), ".hmem", "memory.hmem");
 }
-/**
- * @deprecated Use `new HmemStore(resolveHmemPath(), config)` instead.
- */
-export function openAgentMemory(projectDir, templateName, config) {
-    console.error("[hmem] DEPRECATED: openAgentMemory() — use new HmemStore(resolveHmemPath(), config)");
-    const hmemPath = resolveHmemPathLegacy(projectDir, templateName);
-    return new HmemStore(hmemPath, config);
-}
 /**
  * Open (or create) the shared company knowledge store (company.hmem).
  */
@@ -4201,146 +4178,4 @@ export function openCompanyMemory(projectDir, config) {
     const hmemPath = path.join(projectDir, "company.hmem");
     return new HmemStore(hmemPath, config);
 }
-/**
- * Route a task to the best-matching agent based on memory content.
- * @deprecated This function scans the Agents/ directory structure which is being phased out.
- * Future versions will use a config-based file list instead.
- *
- * Scans all agent .hmem files in the project directory and scores them
- * against the provided tags and/or search keywords.
- *
- * Scoring: for each agent store, find entries sharing the given tags
- * with tier-weighted scoring (rare=3, medium=2, common=1).
- * FTS5 keyword matching supplements tag scoring.
- */
-export function routeTask(projectDir, tags, keywords, limit = 5, config) {
-    // Discover all agent .hmem files — requires multi-agent setup
-    const agentsDir = path.join(projectDir, "Agents");
-    if (!fs.existsSync(agentsDir))
-        return [];
-    const agentDirs = fs.readdirSync(agentsDir).filter(name => {
-        const agentPath = path.join(agentsDir, name);
-        return fs.statSync(agentPath).isDirectory() &&
-            fs.existsSync(path.join(agentPath, `${name}.hmem`));
-    });
-    const results = [];
-    for (const agentName of agentDirs) {
-        const hmemPath = path.join(agentsDir, agentName, `${agentName}.hmem`);
-        let db;
-        try {
-            db = new Database(hmemPath, { readonly: true });
-        }
-        catch {
-            continue;
-        }
-        try {
-            let agentScore = 0;
-            const topEntries = [];
-            // Phase 1: Tag-based scoring
-            if (tags.length > 0) {
-                // Get global tag frequencies for THIS store
-                const freqRows = db.prepare(`
-          SELECT tag, COUNT(DISTINCT
-            CASE WHEN entry_id LIKE '%.%'
-            THEN SUBSTR(entry_id, 1, INSTR(entry_id, '.') - 1)
-            ELSE entry_id END
-          ) as freq FROM memory_tags GROUP BY tag
-        `).all();
-                const tagFreq = new Map();
-                for (const r of freqRows)
-                    tagFreq.set(r.tag, r.freq);
-                // Find entries sharing any of the given tags
-                const normalizedTags = tags.map(t => t.startsWith("#") ? t.toLowerCase() : `#${t.toLowerCase()}`);
-                const placeholders = normalizedTags.map(() => "?").join(", ");
-                const matchRows = db.prepare(`
-          SELECT
-            CASE WHEN entry_id LIKE '%.%'
-            THEN SUBSTR(entry_id, 1, INSTR(entry_id, '.') - 1)
-            ELSE entry_id END as root_id,
-            tag
-          FROM memory_tags WHERE tag IN (${placeholders})
-        `).all(...normalizedTags);
-                // Group by root and score
-                const byRoot = new Map();
-                for (const r of matchRows) {
-                    if (r.root_id.startsWith("O"))
-                        continue; // skip O-entries
-                    let set = byRoot.get(r.root_id);
-                    if (!set) {
-                        set = new Set();
-                        byRoot.set(r.root_id, set);
-                    }
-                    set.add(r.tag);
-                }
-                for (const [rootId, matchedTags] of byRoot) {
-                    let entryScore = 0;
-                    for (const tag of matchedTags) {
-                        const freq = tagFreq.get(tag) ?? 999;
-                        if (freq <= 5)
-                            entryScore += 3;
-                        else if (freq <= 20)
-                            entryScore += 2;
-                        else
-                            entryScore += 1;
-                    }
-                    agentScore += entryScore;
-                    // Get entry title
-                    const row = db.prepare("SELECT title, level_1 FROM memories WHERE id = ? AND obsolete != 1 AND irrelevant != 1").get(rootId);
-                    if (row) {
-                        topEntries.push({
-                            id: rootId,
-                            title: row.title || row.level_1?.substring(0, 50) || rootId,
-                            score: entryScore,
-                        });
-                    }
-                }
-            }
-            // Phase 2: FTS5 keyword supplement
-            if (keywords && keywords.trim().length > 0) {
-                try {
-                    const words = keywords.trim().split(/\s+/).filter(w => w.length > 3).slice(0, 5);
-                    if (words.length > 0) {
-                        const orQuery = words.join(" OR ");
-                        const ftsRows = db.prepare(`
-              SELECT rm.root_id, rm.node_id FROM hmem_fts_rowid_map rm
-              JOIN hmem_fts f ON f.rowid = rm.fts_rowid
-              WHERE hmem_fts MATCH ? LIMIT 20
-            `).all(orQuery);
-                        const ftsRoots = new Set(ftsRows.map(r => r.root_id).filter(id => !id.startsWith("O")));
-                        for (const rootId of ftsRoots) {
-                            if (topEntries.some(e => e.id === rootId))
-                                continue; // already scored via tags
-                            const row = db.prepare("SELECT title, level_1 FROM memories WHERE id = ? AND obsolete != 1 AND irrelevant != 1").get(rootId);
-                            if (row) {
-                                agentScore += 1; // FTS matches get 1 point each
-                                topEntries.push({
-                                    id: rootId,
-                                    title: row.title || row.level_1?.substring(0, 50) || rootId,
-                                    score: 1,
-                                });
-                            }
-                        }
-                    }
-                }
-                catch { /* FTS5 may not exist in all stores */ }
-            }
-            if (agentScore > 0) {
-                // Sort entries by score, keep top 5
-                topEntries.sort((a, b) => b.score - a.score);
-                results.push({
-                    agent: agentName,
-                    score: agentScore,
-                    entryCount: topEntries.length,
-                    topEntries: topEntries.slice(0, 5),
-                });
-            }
-        }
-        finally {
-            db.close();
-        }
-    }
-    // Sort agents by score
-    results.sort((a, b) => b.score - a.score);
-    return results.slice(0, limit);
-}
 //# sourceMappingURL=hmem-store.js.map