hmem-mcp 3.0.1 → 3.1.1

package/dist/hmem-store.d.ts

@@ -580,3 +580,23 @@ export declare function openAgentMemory(projectDir: string, templateName: string
  * Open (or create) the shared company knowledge store (company.hmem).
  */
 export declare function openCompanyMemory(projectDir: string, config?: HmemConfig): HmemStore;
+export interface AgentRouteResult {
+    agent: string;
+    score: number;
+    entryCount: number;
+    topEntries: {
+        id: string;
+        title: string;
+        score: number;
+    }[];
+}
+/**
+ * Route a task to the best-matching agent based on memory content.
+ * 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 declare function routeTask(projectDir: string, tags: string[], keywords?: string, limit?: number, config?: HmemConfig): AgentRouteResult[];

package/dist/hmem-store.js

@@ -2993,4 +2993,143 @@ 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.
+ * 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