@tekmidian/pai 0.1.0

package/dist/tools-CLK4080-.mjs

@@ -0,0 +1,805 @@
+import { i as searchMemoryHybrid, n as populateSlugs } from "./search-PjftDxxs.mjs";
+import { r as formatDetectionJson, t as detectProject } from "./detect-BHqYcjJ1.mjs";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { isAbsolute, join, resolve } from "node:path";
+
+//#region src/mcp/tools.ts
+/**
+* PAI Knowledge OS — Pure tool handler functions (shared by daemon + legacy MCP server)
+*
+* Each function accepts pre-opened database handles and raw params, executes
+* the tool logic, and returns an MCP-style content array.
+*
+* This module does NOT import indexAll() — indexing is handled by the daemon
+* on its own schedule. The search hot path is pure DB read.
+*/
+function lookupProjectId(registryDb, slug) {
+	const bySlug = registryDb.prepare("SELECT id FROM projects WHERE slug = ?").get(slug);
+	if (bySlug) return bySlug.id;
+	const byAlias = registryDb.prepare("SELECT project_id FROM aliases WHERE alias = ?").get(slug);
+	if (byAlias) return byAlias.project_id;
+	return null;
+}
+function detectProjectFromPath(registryDb, fsPath) {
+	const resolved = resolve(fsPath);
+	const exact = registryDb.prepare("SELECT id, slug, display_name, root_path, type, status, created_at, updated_at FROM projects WHERE root_path = ?").get(resolved);
+	if (exact) return exact;
+	const all = registryDb.prepare("SELECT id, slug, display_name, root_path, type, status, created_at, updated_at FROM projects ORDER BY LENGTH(root_path) DESC").all();
+	for (const project of all) if (resolved.startsWith(project.root_path + "/") || resolved === project.root_path) return project;
+	return null;
+}
+function formatProject(registryDb, project) {
+	const sessionCount = registryDb.prepare("SELECT COUNT(*) AS n FROM sessions WHERE project_id = ?").get(project.id).n;
+	const lastSession = registryDb.prepare("SELECT date FROM sessions WHERE project_id = ? ORDER BY date DESC LIMIT 1").get(project.id);
+	const tags = registryDb.prepare(`SELECT t.name FROM tags t
+         JOIN project_tags pt ON pt.tag_id = t.id
+         WHERE pt.project_id = ?
+         ORDER BY t.name`).all(project.id).map((r) => r.name);
+	const aliases = registryDb.prepare("SELECT alias FROM aliases WHERE project_id = ? ORDER BY alias").all(project.id).map((r) => r.alias);
+	const lines = [
+		`slug: ${project.slug}`,
+		`display_name: ${project.display_name}`,
+		`root_path: ${project.root_path}`,
+		`type: ${project.type}`,
+		`status: ${project.status}`,
+		`sessions: ${sessionCount}`
+	];
+	if (lastSession) lines.push(`last_session: ${lastSession.date}`);
+	if (tags.length) lines.push(`tags: ${tags.join(", ")}`);
+	if (aliases.length) lines.push(`aliases: ${aliases.join(", ")}`);
+	if (project.obsidian_link) lines.push(`obsidian_link: ${project.obsidian_link}`);
+	if (project.archived_at) lines.push(`archived_at: ${new Date(project.archived_at).toISOString().slice(0, 10)}`);
+	return lines.join("\n");
+}
+async function toolMemorySearch(registryDb, federation, params) {
+	try {
+		const projectIds = params.project ? (() => {
+			const id = lookupProjectId(registryDb, params.project);
+			return id != null ? [id] : [];
+		})() : void 0;
+		if (params.project && (!projectIds || projectIds.length === 0)) return {
+			content: [{
+				type: "text",
+				text: `Project not found: ${params.project}`
+			}],
+			isError: true
+		};
+		const mode = params.mode ?? "keyword";
+		const snippetLength = params.snippetLength ?? 200;
+		const searchOpts = {
+			projectIds,
+			sources: params.sources,
+			maxResults: params.limit ?? 5
+		};
+		let results;
+		const isBackend = (x) => "backendType" in x;
+		if (isBackend(federation)) if (mode === "keyword") results = await federation.searchKeyword(params.query, searchOpts);
+		else if (mode === "semantic" || mode === "hybrid") {
+			const { generateEmbedding } = await import("./embeddings-mfqv-jFu.mjs").then((n) => n.i);
+			const queryEmbedding = await generateEmbedding(params.query, true);
+			if (mode === "semantic") results = await federation.searchSemantic(queryEmbedding, searchOpts);
+			else {
+				const [kwResults, semResults] = await Promise.all([federation.searchKeyword(params.query, {
+					...searchOpts,
+					maxResults: 50
+				}), federation.searchSemantic(queryEmbedding, {
+					...searchOpts,
+					maxResults: 50
+				})]);
+				results = combineHybridResults(kwResults, semResults, searchOpts.maxResults ?? 10);
+			}
+		} else results = await federation.searchKeyword(params.query, searchOpts);
+		else {
+			const { searchMemory, searchMemorySemantic } = await import("./search-PjftDxxs.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-mfqv-jFu.mjs").then((n) => n.i);
+				const queryEmbedding = await generateEmbedding(params.query, true);
+				if (mode === "semantic") results = searchMemorySemantic(federation, queryEmbedding, searchOpts);
+				else results = searchMemoryHybrid(federation, params.query, queryEmbedding, searchOpts);
+			} else results = searchMemory(federation, params.query, searchOpts);
+		}
+		const withSlugs = populateSlugs(results, registryDb);
+		if (withSlugs.length === 0) return { content: [{
+			type: "text",
+			text: `No results found for query: "${params.query}" (mode: ${mode})`
+		}] };
+		const formatted = withSlugs.map((r, i) => {
+			const header = `[${i + 1}] ${r.projectSlug ?? `project:${r.projectId}`} — ${r.path} (lines ${r.startLine}-${r.endLine}) score=${r.score.toFixed(4)} tier=${r.tier} source=${r.source}`;
+			const raw = r.snippet.trim();
+			return `${header}\n${raw.length > snippetLength ? raw.slice(0, snippetLength) + "..." : raw}`;
+		}).join("\n\n---\n\n");
+		return { content: [{
+			type: "text",
+			text: `Found ${withSlugs.length} result(s) for "${params.query}" (mode: ${mode}):\n\n${formatted}`
+		}] };
+	} catch (e) {
+		return {
+			content: [{
+				type: "text",
+				text: `Search error: ${String(e)}`
+			}],
+			isError: true
+		};
+	}
+}
+function toolMemoryGet(registryDb, params) {
+	try {
+		const projectId = lookupProjectId(registryDb, params.project);
+		if (projectId == null) return {
+			content: [{
+				type: "text",
+				text: `Project not found: ${params.project}`
+			}],
+			isError: true
+		};
+		const project = registryDb.prepare("SELECT root_path FROM projects WHERE id = ?").get(projectId);
+		if (!project) return {
+			content: [{
+				type: "text",
+				text: `Project not found: ${params.project}`
+			}],
+			isError: true
+		};
+		const requestedPath = params.path;
+		if (requestedPath.includes("..") || isAbsolute(requestedPath)) return {
+			content: [{
+				type: "text",
+				text: `Invalid path: ${params.path} (must be a relative path within the project root, no ../ allowed)`
+			}],
+			isError: true
+		};
+		const fullPath = join(project.root_path, requestedPath);
+		const resolvedFull = resolve(fullPath);
+		const resolvedRoot = resolve(project.root_path);
+		if (!resolvedFull.startsWith(resolvedRoot + "/") && resolvedFull !== resolvedRoot) return {
+			content: [{
+				type: "text",
+				text: `Path traversal blocked: ${params.path}`
+			}],
+			isError: true
+		};
+		if (!existsSync(fullPath)) return {
+			content: [{
+				type: "text",
+				text: `File not found: ${requestedPath} (project: ${params.project})`
+			}],
+			isError: true
+		};
+		const stat = statSync(fullPath);
+		if (stat.size > 5 * 1024 * 1024) return { content: [{
+			type: "text",
+			text: `Error: file too large (${(stat.size / 1024 / 1024).toFixed(1)} MB). Maximum 5 MB.`
+		}] };
+		const allLines = readFileSync(fullPath, "utf8").split("\n");
+		const fromLine = (params.from ?? 1) - 1;
+		const toLine = params.lines != null ? Math.min(fromLine + params.lines, allLines.length) : allLines.length;
+		const text = allLines.slice(fromLine, toLine).join("\n");
+		return { content: [{
+			type: "text",
+			text: `${params.from != null ? `${params.project}/${requestedPath} (lines ${fromLine + 1}-${toLine}):` : `${params.project}/${requestedPath}:`}\n\n${text}`
+		}] };
+	} catch (e) {
+		return {
+			content: [{
+				type: "text",
+				text: `Read error: ${String(e)}`
+			}],
+			isError: true
+		};
+	}
+}
+function toolProjectInfo(registryDb, params) {
+	try {
+		let project = null;
+		if (params.slug) {
+			const projectId = lookupProjectId(registryDb, params.slug);
+			if (projectId != null) project = registryDb.prepare("SELECT id, slug, display_name, root_path, type, status, created_at, updated_at, archived_at, parent_id, obsidian_link FROM projects WHERE id = ?").get(projectId);
+		} else project = detectProjectFromPath(registryDb, process.cwd());
+		if (!project) return {
+			content: [{
+				type: "text",
+				text: params.slug ? `Project not found: ${params.slug}` : `No PAI project found matching the current directory: ${process.cwd()}`
+			}],
+			isError: !params.slug
+		};
+		return { content: [{
+			type: "text",
+			text: formatProject(registryDb, project)
+		}] };
+	} catch (e) {
+		return {
+			content: [{
+				type: "text",
+				text: `project_info error: ${String(e)}`
+			}],
+			isError: true
+		};
+	}
+}
+function toolProjectList(registryDb, params) {
+	try {
+		const conditions = [];
+		const queryParams = [];
+		if (params.status) {
+			conditions.push("p.status = ?");
+			queryParams.push(params.status);
+		}
+		if (params.tag) {
+			conditions.push("p.id IN (SELECT pt.project_id FROM project_tags pt JOIN tags t ON pt.tag_id = t.id WHERE t.name = ?)");
+			queryParams.push(params.tag);
+		}
+		const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+		const limit = params.limit ?? 50;
+		queryParams.push(limit);
+		const projects = registryDb.prepare(`SELECT p.id, p.slug, p.display_name, p.root_path, p.type, p.status, p.updated_at
+         FROM projects p
+         ${where}
+         ORDER BY p.updated_at DESC
+         LIMIT ?`).all(...queryParams);
+		if (projects.length === 0) return { content: [{
+			type: "text",
+			text: "No projects found matching the given filters."
+		}] };
+		const lines = projects.map((p) => `${p.slug}  [${p.status}]  ${p.root_path}  (updated: ${new Date(p.updated_at).toISOString().slice(0, 10)})`);
+		return { content: [{
+			type: "text",
+			text: `${projects.length} project(s):\n\n${lines.join("\n")}`
+		}] };
+	} catch (e) {
+		return {
+			content: [{
+				type: "text",
+				text: `project_list error: ${String(e)}`
+			}],
+			isError: true
+		};
+	}
+}
+function toolSessionList(registryDb, params) {
+	try {
+		const projectId = lookupProjectId(registryDb, params.project);
+		if (projectId == null) return {
+			content: [{
+				type: "text",
+				text: `Project not found: ${params.project}`
+			}],
+			isError: true
+		};
+		const conditions = ["project_id = ?"];
+		const queryParams = [projectId];
+		if (params.status) {
+			conditions.push("status = ?");
+			queryParams.push(params.status);
+		}
+		const limit = params.limit ?? 10;
+		queryParams.push(limit);
+		const sessions = registryDb.prepare(`SELECT number, date, title, filename, status
+         FROM sessions
+         WHERE ${conditions.join(" AND ")}
+         ORDER BY number DESC
+         LIMIT ?`).all(...queryParams);
+		if (sessions.length === 0) return { content: [{
+			type: "text",
+			text: `No sessions found for project: ${params.project}`
+		}] };
+		const lines = sessions.map((s) => `#${String(s.number).padStart(4, "0")}  ${s.date}  [${s.status}]  ${s.title}\n        file: Notes/${s.filename}`);
+		return { content: [{
+			type: "text",
+			text: `${sessions.length} session(s) for ${params.project}:\n\n${lines.join("\n\n")}`
+		}] };
+	} catch (e) {
+		return {
+			content: [{
+				type: "text",
+				text: `session_list error: ${String(e)}`
+			}],
+			isError: true
+		};
+	}
+}
+function toolRegistrySearch(registryDb, params) {
+	try {
+		const q = `%${params.query}%`;
+		const projects = registryDb.prepare(`SELECT id, slug, display_name, root_path, type, status, updated_at
+         FROM projects
+         WHERE slug LIKE ?
+            OR display_name LIKE ?
+            OR root_path LIKE ?
+         ORDER BY updated_at DESC
+         LIMIT 20`).all(q, q, q);
+		if (projects.length === 0) return { content: [{
+			type: "text",
+			text: `No projects found matching: "${params.query}"`
+		}] };
+		const lines = projects.map((p) => `${p.slug}  [${p.status}]  ${p.root_path}`);
+		return { content: [{
+			type: "text",
+			text: `${projects.length} match(es) for "${params.query}":\n\n${lines.join("\n")}`
+		}] };
+	} catch (e) {
+		return {
+			content: [{
+				type: "text",
+				text: `registry_search error: ${String(e)}`
+			}],
+			isError: true
+		};
+	}
+}
+function toolProjectDetect(registryDb, params) {
+	try {
+		const detection = detectProject(registryDb, params.cwd);
+		if (!detection) return { content: [{
+			type: "text",
+			text: `No registered project found for path: ${params.cwd ?? process.cwd()}\n\nRun 'pai project add .' to register this directory.`
+		}] };
+		return { content: [{
+			type: "text",
+			text: formatDetectionJson(detection)
+		}] };
+	} catch (e) {
+		return {
+			content: [{
+				type: "text",
+				text: `project_detect error: ${String(e)}`
+			}],
+			isError: true
+		};
+	}
+}
+async function toolProjectHealth(registryDb, params) {
+	try {
+		const { existsSync: fsExists, readdirSync, statSync } = await import("node:fs");
+		const { join: pathJoin, basename: pathBasename } = await import("node:path");
+		const { homedir } = await import("node:os");
+		const { encodeDir: enc } = await import("./utils-DEWdIFQ0.mjs").then((n) => n.h);
+		const rows = registryDb.prepare(`SELECT p.id, p.slug, p.display_name, p.root_path, p.encoded_dir, p.status, p.type,
+           (SELECT COUNT(*) FROM sessions s WHERE s.project_id = p.id) AS session_count
+         FROM projects p
+         ORDER BY p.slug ASC`).all();
+		const home = homedir();
+		const claudeProjects = pathJoin(home, ".claude", "projects");
+		function suggestMoved(rootPath) {
+			const name = pathBasename(rootPath);
+			return [
+				pathJoin(home, "dev", name),
+				pathJoin(home, "dev", "ai", name),
+				pathJoin(home, "Desktop", name),
+				pathJoin(home, "Projects", name)
+			].find((c) => fsExists(c));
+		}
+		function hasClaudeNotes(encodedDir) {
+			if (!fsExists(claudeProjects)) return false;
+			try {
+				for (const entry of readdirSync(claudeProjects)) {
+					if (entry !== encodedDir && !entry.startsWith(encodedDir)) continue;
+					const full = pathJoin(claudeProjects, entry);
+					try {
+						if (!statSync(full).isDirectory()) continue;
+					} catch {
+						continue;
+					}
+					if (fsExists(pathJoin(full, "Notes"))) return true;
+				}
+			} catch {}
+			return false;
+		}
+		function findTodoForProject(rootPath) {
+			for (const rel of [
+				"Notes/TODO.md",
+				".claude/Notes/TODO.md",
+				"tasks/todo.md",
+				"TODO.md"
+			]) {
+				const full = pathJoin(rootPath, rel);
+				if (fsExists(full)) try {
+					const raw = readFileSync(full, "utf8");
+					return {
+						found: true,
+						path: rel,
+						has_continue: /^## Continue$/m.test(raw)
+					};
+				} catch {
+					return {
+						found: true,
+						path: rel,
+						has_continue: false
+					};
+				}
+			}
+			return {
+				found: false,
+				path: null,
+				has_continue: false
+			};
+		}
+		const results = rows.map((p) => {
+			const pathExists = fsExists(p.root_path);
+			let health;
+			let suggestedPath = null;
+			if (pathExists) health = "active";
+			else {
+				suggestedPath = suggestMoved(p.root_path) ?? null;
+				health = suggestedPath ? "stale" : "dead";
+			}
+			const todo = pathExists ? findTodoForProject(p.root_path) : {
+				found: false,
+				path: null,
+				has_continue: false
+			};
+			return {
+				slug: p.slug,
+				display_name: p.display_name,
+				root_path: p.root_path,
+				status: p.status,
+				type: p.type,
+				session_count: p.session_count,
+				health,
+				suggested_path: suggestedPath,
+				has_claude_notes: hasClaudeNotes(p.encoded_dir),
+				todo
+			};
+		});
+		const filtered = !params.category || params.category === "all" ? results : results.filter((r) => r.health === params.category);
+		const summary = {
+			total: rows.length,
+			active: results.filter((r) => r.health === "active").length,
+			stale: results.filter((r) => r.health === "stale").length,
+			dead: results.filter((r) => r.health === "dead").length
+		};
+		return { content: [{
+			type: "text",
+			text: JSON.stringify({
+				summary,
+				projects: filtered
+			}, null, 2)
+		}] };
+	} catch (e) {
+		return {
+			content: [{
+				type: "text",
+				text: `project_health error: ${String(e)}`
+			}],
+			isError: true
+		};
+	}
+}
+/**
+* TODO candidate locations searched in priority order.
+* Returns the first one that exists, along with its label.
+*/
+const TODO_LOCATIONS = [
+	{
+		rel: "Notes/TODO.md",
+		label: "Notes/TODO.md"
+	},
+	{
+		rel: ".claude/Notes/TODO.md",
+		label: ".claude/Notes/TODO.md"
+	},
+	{
+		rel: "tasks/todo.md",
+		label: "tasks/todo.md"
+	},
+	{
+		rel: "TODO.md",
+		label: "TODO.md"
+	}
+];
+/**
+* Given TODO file content, extract and surface the ## Continue section first,
+* then return the remaining content. Returns an object with:
+*   continueSection: string | null
+*   fullContent: string
+*   hasContinue: boolean
+*/
+function parseTodoContent(raw) {
+	const lines = raw.split("\n");
+	const continueIdx = lines.findIndex((l) => l.trim() === "## Continue");
+	if (continueIdx === -1) return {
+		continueSection: null,
+		fullContent: raw,
+		hasContinue: false
+	};
+	let endIdx = lines.length;
+	for (let i = continueIdx + 1; i < lines.length; i++) {
+		const trimmed = lines[i].trim();
+		if (trimmed === "---" || trimmed.startsWith("##") && trimmed !== "## Continue") {
+			endIdx = i;
+			break;
+		}
+	}
+	return {
+		continueSection: lines.slice(continueIdx, endIdx).join("\n").trim(),
+		fullContent: raw,
+		hasContinue: true
+	};
+}
+function toolProjectTodo(registryDb, params) {
+	try {
+		let rootPath;
+		let projectSlug;
+		if (params.project) {
+			const projectId = lookupProjectId(registryDb, params.project);
+			if (projectId == null) return {
+				content: [{
+					type: "text",
+					text: `Project not found: ${params.project}`
+				}],
+				isError: true
+			};
+			const row = registryDb.prepare("SELECT root_path, slug FROM projects WHERE id = ?").get(projectId);
+			if (!row) return {
+				content: [{
+					type: "text",
+					text: `Project not found: ${params.project}`
+				}],
+				isError: true
+			};
+			rootPath = row.root_path;
+			projectSlug = row.slug;
+		} else {
+			const project = detectProjectFromPath(registryDb, process.cwd());
+			if (!project) return { content: [{
+				type: "text",
+				text: `No PAI project found matching the current directory: ${process.cwd()}\n\nProvide a project slug or run 'pai project add .' to register this directory.`
+			}] };
+			rootPath = project.root_path;
+			projectSlug = project.slug;
+		}
+		for (const loc of TODO_LOCATIONS) {
+			const fullPath = join(rootPath, loc.rel);
+			if (existsSync(fullPath)) {
+				const { continueSection, fullContent, hasContinue } = parseTodoContent(readFileSync(fullPath, "utf8"));
+				let output;
+				if (hasContinue && continueSection) output = [
+					`TODO found: ${projectSlug}/${loc.label}`,
+					"",
+					"=== CONTINUE SECTION (surfaced first) ===",
+					continueSection,
+					"",
+					"=== FULL TODO CONTENT ===",
+					fullContent
+				].join("\n");
+				else output = [
+					`TODO found: ${projectSlug}/${loc.label}`,
+					"",
+					fullContent
+				].join("\n");
+				return { content: [{
+					type: "text",
+					text: output
+				}] };
+			}
+		}
+		const searched = TODO_LOCATIONS.map((l) => `  ${rootPath}/${l.rel}`).join("\n");
+		return { content: [{
+			type: "text",
+			text: [
+				`No TODO.md found for project: ${projectSlug}`,
+				"",
+				"Searched locations (in order):",
+				searched,
+				"",
+				"Create a TODO with: echo '## Tasks\\n- [ ] First task' > Notes/TODO.md"
+			].join("\n")
+		}] };
+	} catch (e) {
+		return {
+			content: [{
+				type: "text",
+				text: `project_todo error: ${String(e)}`
+			}],
+			isError: true
+		};
+	}
+}
+/**
+* Handle notification config queries and updates via the daemon IPC.
+* Falls back gracefully if the daemon is not running.
+*/
+async function toolNotificationConfig(params) {
+	try {
+		const { PaiClient } = await import("./ipc-client-DPy7s3iu.mjs").then((n) => n.n);
+		const client = new PaiClient();
+		if (params.action === "get") {
+			const { config, activeChannels } = await client.getNotificationConfig();
+			return { content: [{
+				type: "text",
+				text: [
+					`mode: ${config.mode}`,
+					`active_channels: ${activeChannels.join(", ") || "(none)"}`,
+					"",
+					"channels:",
+					...Object.entries(config.channels).map(([ch, cfg]) => {
+						return `  ${ch}: ${cfg.enabled ? "enabled" : "disabled"}`;
+					}),
+					"",
+					"routing:",
+					...Object.entries(config.routing).map(([event, channels]) => `  ${event}: ${channels.join(", ") || "(none)"}`)
+				].join("\n")
+			}] };
+		}
+		if (params.action === "set") {
+			if (!params.mode && !params.channels && !params.routing) return {
+				content: [{
+					type: "text",
+					text: "notification_config set: provide at least one of mode, channels, or routing."
+				}],
+				isError: true
+			};
+			return { content: [{
+				type: "text",
+				text: `Notification config updated. Mode: ${(await client.setNotificationConfig({
+					mode: params.mode,
+					channels: params.channels,
+					routing: params.routing
+				})).config.mode}`
+			}] };
+		}
+		if (params.action === "send") {
+			if (!params.message) return {
+				content: [{
+					type: "text",
+					text: "notification_config send: message is required."
+				}],
+				isError: true
+			};
+			const result = await client.sendNotification({
+				event: params.event ?? "info",
+				message: params.message,
+				title: params.title
+			});
+			return { content: [{
+				type: "text",
+				text: [
+					`mode: ${result.mode}`,
+					`attempted: ${result.channelsAttempted.join(", ") || "(none)"}`,
+					`succeeded: ${result.channelsSucceeded.join(", ") || "(none)"}`,
+					...result.channelsFailed.length > 0 ? [`failed: ${result.channelsFailed.join(", ")}`] : []
+				].join("\n")
+			}] };
+		}
+		return {
+			content: [{
+				type: "text",
+				text: `Unknown action: ${String(params.action)}. Use "get", "set", or "send".`
+			}],
+			isError: true
+		};
+	} catch (e) {
+		return {
+			content: [{
+				type: "text",
+				text: `notification_config error: ${String(e)}`
+			}],
+			isError: true
+		};
+	}
+}
+/**
+* Detect whether recent conversation context has shifted to a different project.
+* Uses memory_search to find which project best matches the context, then
+* compares against the current project.
+*
+* Calls the daemon via IPC so it has access to the storage backend.
+* Falls back gracefully if the daemon is not running.
+*/
+async function toolTopicDetect(params) {
+	try {
+		const { PaiClient } = await import("./ipc-client-DPy7s3iu.mjs").then((n) => n.n);
+		const result = await new PaiClient().topicCheck({
+			context: params.context,
+			currentProject: params.current_project,
+			threshold: params.threshold
+		});
+		const lines = [
+			`shifted: ${result.shifted}`,
+			`current_project: ${result.currentProject ?? "(none)"}`,
+			`suggested_project: ${result.suggestedProject ?? "(none)"}`,
+			`confidence: ${result.confidence.toFixed(3)}`,
+			`chunks_scored: ${result.chunkCount}`
+		];
+		if (result.topProjects.length > 0) {
+			lines.push("");
+			lines.push("top_matches:");
+			for (const p of result.topProjects) lines.push(`  ${p.slug}: ${(p.score * 100).toFixed(1)}%`);
+		}
+		if (result.shifted) {
+			lines.push("");
+			lines.push(`TOPIC SHIFT DETECTED: conversation appears to be about "${result.suggestedProject}" (confidence: ${(result.confidence * 100).toFixed(0)}%), not "${result.currentProject}".`);
+		}
+		return { content: [{
+			type: "text",
+			text: lines.join("\n")
+		}] };
+	} catch (e) {
+		return {
+			content: [{
+				type: "text",
+				text: `topic_detect error: ${String(e)}`
+			}],
+			isError: true
+		};
+	}
+}
+/**
+* Automatically suggest which project a session belongs to.
+*
+* Strategy (in priority order):
+*   1. path   — exact or parent-directory match in the project registry
+*   2. marker — walk up from cwd looking for Notes/PAI.md
+*   3. topic  — BM25 keyword search against memory (requires context)
+*
+* Call this at session start (e.g., from CLAUDE.md or a session-start hook)
+* to automatically route the session to the correct project.
+*/
+async function toolSessionRoute(registryDb, federation, params) {
+	try {
+		const { autoRoute, formatAutoRouteJson } = await import("./auto-route-D7W6RE06.mjs");
+		const result = await autoRoute(registryDb, federation, params.cwd, params.context);
+		if (!result) return { content: [{
+			type: "text",
+			text: [
+				`No project match found for: ${params.cwd ?? process.cwd()}`,
+				"",
+				"Tried: path match, PAI.md marker walk" + (params.context ? ", topic detection" : ""),
+				"",
+				"Run 'pai project add .' to register this directory,",
+				"or provide conversation context for topic-based routing."
+			].join("\n")
+		}] };
+		return { content: [{
+			type: "text",
+			text: formatAutoRouteJson(result)
+		}] };
+	} catch (e) {
+		return {
+			content: [{
+				type: "text",
+				text: `session_route error: ${String(e)}`
+			}],
+			isError: true
+		};
+	}
+}
+/**
+* Combine keyword + semantic results using min-max normalized scoring.
+* Mirrors the logic in searchMemoryHybrid() from memory/search.ts,
+* but works on pre-computed result arrays so it works for any backend.
+*/
+function combineHybridResults(keywordResults, semanticResults, maxResults, keywordWeight = .5, semanticWeight = .5) {
+	if (keywordResults.length === 0 && semanticResults.length === 0) return [];
+	const keyFor = (r) => `${r.projectId}:${r.path}:${r.startLine}:${r.endLine}`;
+	function minMaxNormalize(items) {
+		if (items.length === 0) return /* @__PURE__ */ new Map();
+		const min = Math.min(...items.map((r) => r.score));
+		const range = Math.max(...items.map((r) => r.score)) - min;
+		const m = /* @__PURE__ */ new Map();
+		for (const r of items) m.set(keyFor(r), range === 0 ? 1 : (r.score - min) / range);
+		return m;
+	}
+	const kwNorm = minMaxNormalize(keywordResults);
+	const semNorm = minMaxNormalize(semanticResults);
+	const allKeys = new Set([...keywordResults.map(keyFor), ...semanticResults.map(keyFor)]);
+	const metaMap = /* @__PURE__ */ new Map();
+	for (const r of [...keywordResults, ...semanticResults]) metaMap.set(keyFor(r), r);
+	const combined = [];
+	for (const key of allKeys) {
+		const meta = metaMap.get(key);
+		const kwScore = kwNorm.get(key) ?? 0;
+		const semScore = semNorm.get(key) ?? 0;
+		const combinedScore = keywordWeight * kwScore + semanticWeight * semScore;
+		combined.push({
+			...meta,
+			score: combinedScore,
+			combinedScore
+		});
+	}
+	return combined.sort((a, b) => b.score - a.score).slice(0, maxResults).map(({ combinedScore: _unused, ...r }) => r);
+}
+
+//#endregion
+export { toolProjectHealth as a, toolProjectTodo as c, toolSessionRoute as d, toolTopicDetect as f, toolProjectDetect as i, toolRegistrySearch as l, toolMemorySearch as n, toolProjectInfo as o, toolNotificationConfig as r, toolProjectList as s, toolMemoryGet as t, toolSessionList as u };
+//# sourceMappingURL=tools-CLK4080-.mjs.map