@tekmidian/pai 0.9.8 → 0.9.10

package/dist/{tools-gMHdjmHC.mjs → tools-BNBvJNph.mjs}

@@ -1,8 +1,9 @@
 import { t as __exportAll } from "./rolldown-runtime-95iHPtFO.mjs";
+import { n as cosineSimilarity } from "./embeddings-DGRAPAYb.mjs";
 import { t as STOP_WORDS } from "./stop-words-BaMEGVeY.mjs";
-import { i as searchMemoryHybrid, n as populateSlugs } from "./search-DC1qhkKn.mjs";
+import { i as searchMemoryHybrid, n as populateSlugs, s as touchChunksLastAccessed } from "./search-i2nlQ-JM.mjs";
 import { r as formatDetectionJson, t as detectProject } from "./detect-CdaA48EI.mjs";
-import { i as kgQuery, n as kgContradictions, r as kgInvalidate, t as kgAdd } from "./kg-B5ysyRLC.mjs";
+import { a as kgContradictions, i as kgAdd, n as updateEntityFeedbackWeight, o as kgInvalidate, s as kgQuery, t as listKgEntities } from "./kg-entity-D5v7RCDi.mjs";
 import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { basename, isAbsolute, join, resolve } from "node:path";
@@ -94,7 +95,7 @@ async function toolMemorySearch(registryDb, federation, params, searchDefaults)
 			}
 		} else results = await federation.searchKeyword(params.query, searchOpts);
 		else {
-			const { searchMemory, searchMemorySemantic } = await import("./search-DC1qhkKn.mjs").then((n) => n.o);
+			const { searchMemory, searchMemorySemantic } = await import("./search-i2nlQ-JM.mjs").then((n) => n.o);
 			if (mode === "keyword") results = searchMemory(federation, params.query, searchOpts);
 			else if (mode === "semantic" || mode === "hybrid") {
 				const { generateEmbedding } = await import("./embeddings-DGRAPAYb.mjs").then((n) => n.i);
@@ -103,6 +104,13 @@ async function toolMemorySearch(registryDb, federation, params, searchDefaults)
 				else results = searchMemoryHybrid(federation, params.query, queryEmbedding, searchOpts);
 			} else results = searchMemory(federation, params.query, searchOpts);
 		}
+		try {
+			const chunkIds = results.map((r) => r.chunkId).filter((id) => id != null);
+			if (chunkIds.length > 0) {
+				const rawDb = !isBackend(federation) ? federation : federation.getSqliteDb?.() ?? null;
+				if (rawDb) touchChunksLastAccessed(rawDb, chunkIds);
+			}
+		} catch {}
 		const shouldRerank = params.rerank ?? searchDefaults?.rerank ?? true;
 		if (shouldRerank && results.length > 0) {
 			const { rerankResults } = await import("./reranker-CMNZcfVx.mjs").then((n) => n.r);
@@ -110,7 +118,7 @@ async function toolMemorySearch(registryDb, federation, params, searchDefaults)
 		}
 		const recencyDays = params.recencyBoost ?? searchDefaults?.recencyBoostDays ?? 0;
 		if (recencyDays > 0 && results.length > 0) {
-			const { applyRecencyBoost } = await import("./search-DC1qhkKn.mjs").then((n) => n.o);
+			const { applyRecencyBoost } = await import("./search-i2nlQ-JM.mjs").then((n) => n.o);
 			results = applyRecencyBoost(results, recencyDays);
 		}
 		const withSlugs = populateSlugs(results, registryDb);
@@ -653,7 +661,7 @@ function toolSessionList(registryDb, params) {
 */
 async function toolSessionRoute(registryDb, federation, params) {
 	try {
-		const { autoRoute, formatAutoRouteJson } = await import("./auto-route-CruBrTf-.mjs");
+		const { autoRoute, formatAutoRouteJson } = await import("./auto-route-DL4ViDKC.mjs");
 		const result = await autoRoute(registryDb, federation, params.cwd, params.context);
 		if (!result) return { content: [{
 			type: "text",
@@ -1604,6 +1612,274 @@ async function toolMemoryTunnels(registryDb, backend, params) {
 	}
 }
 
+//#endregion
+//#region src/mcp/tools/feedback.ts
+const FEEDBACK_ALPHA = .1;
+/**
+* Apply relevance feedback to memory chunks and associated KG entities.
+*
+* @param db      Federation SQLite database
+* @param params  Feedback parameters
+*/
+function toolMemoryFeedback(db, params) {
+	try {
+		if (!Array.isArray(params.chunk_ids) || params.chunk_ids.length === 0) return {
+			content: [{
+				type: "text",
+				text: "memory_feedback error: chunk_ids must be a non-empty array"
+			}],
+			isError: true
+		};
+		const rating = params.rating;
+		if (typeof rating !== "number" || rating < 1 || rating > 5) return {
+			content: [{
+				type: "text",
+				text: "memory_feedback error: rating must be a number between 1 and 5"
+			}],
+			isError: true
+		};
+		const normalizedRating = (rating - 1) / 4;
+		const placeholders = params.chunk_ids.map(() => "?").join(", ");
+		const chunks = db.prepare(`SELECT id, text, relevance_score FROM memory_chunks WHERE id IN (${placeholders})`).all(...params.chunk_ids);
+		if (chunks.length === 0) return {
+			content: [{
+				type: "text",
+				text: "memory_feedback: no matching chunks found"
+			}],
+			isError: true
+		};
+		let updatedChunks = 0;
+		const combinedText = [];
+		const updateStmt = db.prepare("UPDATE memory_chunks SET relevance_score = ? WHERE id = ?");
+		for (const chunk of chunks) {
+			const oldScore = chunk.relevance_score ?? .5;
+			const newScore = oldScore + FEEDBACK_ALPHA * (normalizedRating - oldScore);
+			updateStmt.run(newScore, chunk.id);
+			updatedChunks++;
+			combinedText.push(chunk.text);
+		}
+		const entities = listKgEntities(db, params.tenant_id ?? "default", void 0, 500);
+		const text = combinedText.join("\n").toLowerCase();
+		let updatedEntities = 0;
+		for (const entity of entities) if (text.includes(entity.name.toLowerCase())) {
+			updateEntityFeedbackWeight(db, entity.entity_id, normalizedRating, FEEDBACK_ALPHA);
+			updatedEntities++;
+		}
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				updated_chunks: updatedChunks,
+				updated_entities: updatedEntities,
+				rating,
+				normalized_rating: normalizedRating
+			})
+		}] };
+	} catch (e) {
+		return {
+			content: [{
+				type: "text",
+				text: `memory_feedback error: ${String(e)}`
+			}],
+			isError: true
+		};
+	}
+}
+
+//#endregion
+//#region src/memory/kg-search.ts
+/**
+* Find entity names (from the federation.db kg_entities table) that appear
+* as substrings in the given text chunks.
+*
+* Returns a deduplicated list of matching entity names.
+*/
+function extractEntityMentions(federationDb, chunks, tenantId = "default") {
+	const entities = listKgEntities(federationDb, tenantId, void 0, 500);
+	if (entities.length === 0) return [];
+	const combinedText = chunks.map((c) => c.snippet).join("\n").toLowerCase();
+	const matched = /* @__PURE__ */ new Set();
+	for (const entity of entities) if (combinedText.includes(entity.name.toLowerCase())) matched.add(entity.name);
+	return Array.from(matched);
+}
+/**
+* Perform BFS over kg_triples to find neighbors of the given entity names.
+*
+* For each entity name, fetches triples where the entity is the subject
+* or the object (bi-directional expansion). Supports 1 or 2 hop depths.
+*
+* Returns all unique triples found in the BFS expansion.
+*/
+async function bfsExpand(pool, entityNames, hops, projectId) {
+	const seen = /* @__PURE__ */ new Set();
+	const tripleMap = /* @__PURE__ */ new Map();
+	const frontier = new Set(entityNames);
+	for (let hop = 0; hop < hops; hop++) {
+		const nextFrontier = /* @__PURE__ */ new Set();
+		for (const name of frontier) {
+			const asSubject = await kgQuery(pool, {
+				subject: name,
+				project_id: projectId
+			});
+			const asObject = await kgQuery(pool, {
+				object: name,
+				project_id: projectId
+			});
+			for (const triple of [...asSubject, ...asObject]) if (!seen.has(triple.id)) {
+				seen.add(triple.id);
+				tripleMap.set(triple.id, triple);
+				nextFrontier.add(triple.subject);
+				nextFrontier.add(triple.object);
+			}
+		}
+		frontier.clear();
+		for (const name of nextFrontier) if (!entityNames.includes(name)) {
+			frontier.add(name);
+			entityNames.push(name);
+		}
+	}
+	return Array.from(tripleMap.values());
+}
+/**
+* Score each triple by cosine similarity to the query embedding.
+*
+* The triple text representation is: "subject predicate object"
+* We embed this on-the-fly using generateEmbedding(), which may use a cache.
+*
+* Returns triples sorted by relevance score descending.
+*/
+async function rerankTriples(triples, queryVec, maxTriples) {
+	if (triples.length === 0) return [];
+	const { generateEmbedding } = await import("./embeddings-DGRAPAYb.mjs").then((n) => n.i);
+	return (await Promise.all(triples.map(async (triple) => {
+		const text = `${triple.subject} ${triple.predicate} ${triple.object}`;
+		try {
+			const score = cosineSimilarity(queryVec, await generateEmbedding(text, false));
+			return {
+				...triple,
+				relevanceScore: score
+			};
+		} catch {
+			return {
+				...triple,
+				relevanceScore: 0
+			};
+		}
+	}))).sort((a, b) => b.relevanceScore - a.relevanceScore).slice(0, maxTriples);
+}
+/**
+* Graph-completion retrieval combining vector search with KG neighborhood BFS.
+*
+* @param federationDb  SQLite federation.db (for chunk/entity lookup)
+* @param pool          Postgres connection pool (for kg_triples queries)
+* @param queryVec      Pre-computed embedding for the search query
+* @param opts          Configuration options
+*/
+async function graphCompletionSearch(federationDb, pool, queryVec, opts = {}) {
+	const { seedCount = 50, hops = 1, maxTriples = 20, projectId, tenantId = "default", searchOpts } = opts;
+	const seedSearchOpts = {
+		...searchOpts,
+		maxResults: seedCount,
+		projectIds: projectId != null ? [projectId] : searchOpts?.projectIds
+	};
+	let seedChunks = [];
+	try {
+		const { searchMemorySemantic } = await import("./search-i2nlQ-JM.mjs").then((n) => n.o);
+		seedChunks = searchMemorySemantic(federationDb, queryVec, seedSearchOpts);
+	} catch (e) {
+		process.stderr.write(`[kg-search] Phase 1 seed search error: ${e}\n`);
+	}
+	if (seedChunks.length === 0) return {
+		triples: [],
+		seedChunks: [],
+		expandedEntities: []
+	};
+	const expandedEntities = extractEntityMentions(federationDb, seedChunks, tenantId);
+	if (expandedEntities.length === 0) return {
+		triples: [],
+		seedChunks,
+		expandedEntities: []
+	};
+	let expandedTriples = [];
+	try {
+		expandedTriples = await bfsExpand(pool, [...expandedEntities], hops, projectId);
+	} catch (e) {
+		process.stderr.write(`[kg-search] Phase 3 BFS expansion error: ${e}\n`);
+	}
+	if (expandedTriples.length === 0) return {
+		triples: [],
+		seedChunks,
+		expandedEntities
+	};
+	let rankedTriples = [];
+	try {
+		rankedTriples = await rerankTriples(expandedTriples, queryVec, maxTriples);
+	} catch (e) {
+		process.stderr.write(`[kg-search] Phase 4 rerank error: ${e}\n`);
+		rankedTriples = expandedTriples.slice(0, maxTriples).map((t) => ({
+			...t,
+			relevanceScore: 0
+		}));
+	}
+	return {
+		triples: rankedTriples,
+		seedChunks,
+		expandedEntities
+	};
+}
+
+//#endregion
+//#region src/mcp/tools/kg-search.ts
+/**
+* Graph-completion search: vector search + KG neighborhood BFS.
+*
+* @param federationDb  SQLite federation.db for chunk/entity operations
+* @param pool          Postgres pool for kg_triples BFS expansion
+* @param params        Tool parameters
+*/
+async function toolMemoryKgSearch(federationDb, pool, params) {
+	try {
+		if (!params.query || typeof params.query !== "string" || params.query.trim() === "") return {
+			content: [{
+				type: "text",
+				text: "memory_kg_search error: query is required"
+			}],
+			isError: true
+		};
+		const { generateEmbedding } = await import("./embeddings-DGRAPAYb.mjs").then((n) => n.i);
+		const result = await graphCompletionSearch(federationDb, pool, await generateEmbedding(params.query, true), {
+			seedCount: params.wide_k ?? 50,
+			hops: params.neighborhood_depth ?? 1,
+			maxTriples: params.top_k ?? 20,
+			projectId: params.project_id,
+			tenantId: params.tenant_id ?? "default"
+		});
+		if (result.triples.length === 0) return { content: [{
+			type: "text",
+			text: `No KG triples found for query: "${params.query}"\nSeed chunks: ${result.seedChunks.length}, Expanded entities: ${result.expandedEntities.length}`
+		}] };
+		const tripleLines = result.triples.map((t, i) => `[${i + 1}] (score=${t.relevanceScore.toFixed(4)}) ${t.subject} — ${t.predicate} — ${t.object}`).join("\n");
+		const entityList = result.expandedEntities.slice(0, 10).join(", ");
+		return { content: [{
+			type: "text",
+			text: [
+				`Found ${result.triples.length} KG triple(s) for "${params.query}"`,
+				`Seed chunks: ${result.seedChunks.length}`,
+				`Expanded entities (${result.expandedEntities.length}): ${entityList}`,
+				"",
+				tripleLines
+			].join("\n")
+		}] };
+	} catch (e) {
+		return {
+			content: [{
+				type: "text",
+				text: `memory_kg_search error: ${String(e)}`
+			}],
+			isError: true
+		};
+	}
+}
+
 //#endregion
 //#region src/mcp/tools.ts
 var tools_exports = /* @__PURE__ */ __exportAll({
@@ -1615,7 +1891,9 @@ var tools_exports = /* @__PURE__ */ __exportAll({
 	toolKgContradictions: () => toolKgContradictions,
 	toolKgInvalidate: () => toolKgInvalidate,
 	toolKgQuery: () => toolKgQuery,
+	toolMemoryFeedback: () => toolMemoryFeedback,
 	toolMemoryGet: () => toolMemoryGet,
+	toolMemoryKgSearch: () => toolMemoryKgSearch,
 	toolMemorySearch: () => toolMemorySearch,
 	toolMemoryTaxonomy: () => toolMemoryTaxonomy,
 	toolMemoryTunnels: () => toolMemoryTunnels,
@@ -1639,5 +1917,5 @@ var tools_exports = /* @__PURE__ */ __exportAll({
 });
 
 //#endregion
-export { toolSessionList as a, toolProjectHealth as c, toolProjectTodo as d, toolMemoryGet as f, toolRegistrySearch as i, toolProjectInfo as l, toolMemoryTaxonomy as n, toolSessionRoute as o, toolMemorySearch as p, toolMemoryWakeup as r, toolProjectDetect as s, tools_exports as t, toolProjectList as u };
-//# sourceMappingURL=tools-gMHdjmHC.mjs.map
+export { toolMemoryWakeup as a, toolSessionRoute as c, toolProjectInfo as d, toolProjectList as f, toolMemorySearch as h, toolMemoryTaxonomy as i, toolProjectDetect as l, toolMemoryGet as m, toolMemoryKgSearch as n, toolRegistrySearch as o, toolProjectTodo as p, toolMemoryFeedback as r, toolSessionList as s, tools_exports as t, toolProjectHealth as u };
+//# sourceMappingURL=tools-BNBvJNph.mjs.map