amalfa 1.0.22 → 1.0.24

package/src/mcp/index.ts

@@ -14,11 +14,15 @@ import { ResonanceDB } from "@src/resonance/db";
 import { DaemonManager } from "../utils/DaemonManager";
 import { getLogger } from "../utils/Logger";
 import { ServiceLifecycle } from "../utils/ServiceLifecycle";
+import { createSonarClient, type SonarClient } from "../utils/sonar-client";
 
 const args = process.argv.slice(2);
 const command = args[0] || "serve";
 const log = getLogger("MCP");
 
+// Sonar client for enhanced search
+const sonarClient: SonarClient = await createSonarClient();
+
 // --- Service Lifecycle ---
 
 const lifecycle = new ServiceLifecycle({
@@ -181,11 +185,40 @@ async function runServer() {
 					const limit = Number(args?.limit || 20);
 					const candidates = new Map<
 						string,
-						{ id: string; score: number; preview: string; source: string }
+						{
+							id: string;
+							score: number;
+							preview: string;
+							source: string;
+							content: string;
+						}
 					>();
 					const errors: string[] = [];
 
-					// Vector Search only (FTS removed in Hollow Node migration)
+					// Step 1: Analyze query with Sonar (if available)
+					const sonarAvailable = await sonarClient.isAvailable();
+					let queryAnalysis: Awaited<
+						ReturnType<typeof sonarClient.analyzeQuery>
+					> | null = null;
+					let queryIntent: string | undefined = undefined;
+
+					if (sonarAvailable) {
+						log.info({ query }, "🔍 Analyzing query with Sonar");
+						queryAnalysis = await sonarClient.analyzeQuery(query);
+						if (queryAnalysis) {
+							queryIntent = queryAnalysis.intent;
+							log.info(
+								{
+									intent: queryAnalysis.intent,
+									entities: queryAnalysis.entities.join(", "),
+									level: queryAnalysis.technical_level,
+								},
+								"✅ Query analysis complete",
+							);
+						}
+					}
+
+					// Step 2: Vector Search (FTS removed in Hollow Node migration)
 					try {
 						const vectorResults = await vectorEngine.search(query, limit);
 						for (const r of vectorResults) {
@@ -198,6 +231,7 @@ async function runServer() {
 								score: r.score,
 								preview: preview,
 								source: "vector",
+								content: r.content || "",
 							});
 						}
 					} catch (e: unknown) {
@@ -206,12 +240,63 @@ async function runServer() {
 						errors.push(msg);
 					}
 
-					const results = Array.from(candidates.values())
+					// Step 3: Re-rank results with Sonar (if available)
+					let rankedResults = Array.from(candidates.values())
 						.sort((a, b) => b.score - a.score)
-						.slice(0, limit)
-						.map((r) => ({ ...r, score: r.score.toFixed(3) }));
+						.slice(0, limit);
+
+					if (sonarAvailable && queryAnalysis) {
+						log.info("🔄 Re-ranking results with Sonar");
+						const reRanked = await sonarClient.rerankResults(
+							rankedResults,
+							query,
+							queryIntent,
+						);
+						rankedResults = reRanked.map((rr) => {
+							const original = candidates.get(rr.id)!;
+							return {
+								...original,
+								score: rr.relevance_score,
+							};
+						});
+						log.info("✅ Results re-ranked");
+					}
+
+					// Step 4: Extract context with Sonar for top results (if available)
+					// We'll prepare the final output structure here
+					let finalResults: Array<any> = rankedResults;
+
+					if (sonarAvailable) {
+						log.info("📝 Extracting context with Sonar");
+						const contextResults = await Promise.all(
+							rankedResults.slice(0, 5).map(async (r) => {
+								const context = await sonarClient.extractContext(r, query);
+								return {
+									// ... (keeping structure) ...
+									...r,
+									score: r.score.toFixed(3),
+									snippet: context?.snippet || r.preview,
+									context: context?.context || "No additional context",
+									confidence: context?.confidence || 0.5,
+								};
+							}),
+						);
+						// Combine context results with the rest
+						finalResults = [
+							...contextResults,
+							...rankedResults
+								.slice(5)
+								.map((r) => ({ ...r, score: r.score.toFixed(3) })),
+						];
+						log.info("✅ Context extraction complete");
+					} else {
+						finalResults = rankedResults.map((r) => ({
+							...r,
+							score: r.score.toFixed(3),
+						}));
+					}
 
-					if (results.length === 0 && errors.length > 0) {
+					if (finalResults.length === 0 && errors.length > 0) {
 						return {
 							content: [
 								{ type: "text", text: `Search Error: ${errors.join(", ")}` },
@@ -219,8 +304,29 @@ async function runServer() {
 							isError: true,
 						};
 					}
+
+					// Add Sonar metadata to response
+					const searchMetadata = {
+						query,
+						sonar_enabled: sonarAvailable,
+						intent: queryIntent,
+						analysis: queryAnalysis,
+					};
+
 					return {
-						content: [{ type: "text", text: JSON.stringify(results, null, 2) }],
+						content: [
+							{
+								type: "text",
+								text: JSON.stringify(
+									{
+										results: finalResults,
+										metadata: searchMetadata,
+									},
+									null,
+									2,
+								),
+							},
+						],
 					};
 				} finally {
 					// Cleanup connection
@@ -410,4 +516,4 @@ process.on("unhandledRejection", (reason) => {
 
 // --- Dispatch ---
 
-await lifecycle.run(command, runServer, false);
+await lifecycle.run(command, runServer);

package/src/resonance/db.ts

@@ -366,11 +366,24 @@ export class ResonanceDB {
 	checkpoint() {
 		this.db.run("PRAGMA wal_checkpoint(TRUNCATE);");
 	}
+	getNode(id: string): Node | null {
+		const row = this.db.query("SELECT * FROM nodes WHERE id = ?").get(id);
+		if (!row) return null;
+		return this.mapRowToNode(row);
+	}
+
+	updateNodeMeta(id: string, meta: Record<string, unknown>) {
+		this.db.run("UPDATE nodes SET meta = ? WHERE id = ?", [
+			JSON.stringify(meta),
+			id,
+		]);
+	}
 }
 
 // Helper: Calculate magnitude (L2 norm) of a vector
 function magnitude(vec: Float32Array): number {
 	let sum = 0;
+	// Modern JS engines SIMD-optimize this loop automatically
 	for (let i = 0; i < vec.length; i++) {
 		sum += (vec[i] || 0) * (vec[i] || 0);
 	}

package/src/utils/DaemonManager.ts

@@ -7,6 +7,7 @@ export interface DaemonStatus {
 	running: boolean;
 	pid?: number;
 	port?: number;
+	activeModel?: string;
 }
 
 /**
@@ -16,6 +17,7 @@ export interface DaemonStatus {
 export class DaemonManager {
 	private vectorLifecycle: ServiceLifecycle;
 	private watcherLifecycle: ServiceLifecycle;
+	private sonarLifecycle: ServiceLifecycle;
 
 	constructor() {
 		this.vectorLifecycle = new ServiceLifecycle({
@@ -31,6 +33,13 @@ export class DaemonManager {
 			logFile: join(AMALFA_DIRS.logs, "daemon.log"),
 			entryPoint: "src/daemon/index.ts",
 		});
+
+		this.sonarLifecycle = new ServiceLifecycle({
+			name: "SonarAgent",
+			pidFile: join(AMALFA_DIRS.runtime, "sonar.pid"),
+			logFile: join(AMALFA_DIRS.logs, "sonar.log"),
+			entryPoint: "src/daemon/sonar-agent.ts",
+		});
 	}
 
 	/**
@@ -65,7 +74,9 @@ export class DaemonManager {
 	 * Check if vector daemon is running
 	 */
 	async checkVectorDaemon(): Promise<DaemonStatus> {
-		const pid = await this.readPid(join(AMALFA_DIRS.runtime, "vector-daemon.pid"));
+		const pid = await this.readPid(
+			join(AMALFA_DIRS.runtime, "vector-daemon.pid"),
+		);
 		if (!pid) {
 			return { running: false };
 		}
@@ -126,24 +137,77 @@ export class DaemonManager {
 		await this.watcherLifecycle.stop();
 	}
 
+	/**
+	 * Check if Sonar Agent is running
+	 */
+	async checkSonarAgent(): Promise<DaemonStatus> {
+		const pid = await this.readPid(join(AMALFA_DIRS.runtime, "sonar.pid"));
+		if (!pid) {
+			return { running: false };
+		}
+
+		const running = await this.isProcessRunning(pid);
+		let activeModel: string | undefined;
+
+		if (running) {
+			try {
+				const health = (await fetch("http://localhost:3012/health").then((r) =>
+					r.json(),
+				)) as { model?: string };
+				activeModel = health.model;
+			} catch {
+				// disregard
+			}
+		}
+
+		return {
+			running,
+			pid: running ? pid : undefined,
+			port: running ? 3012 : undefined,
+			activeModel,
+		};
+	}
+
+	/**
+	 * Start Sonar Agent
+	 */
+	async startSonarAgent(): Promise<void> {
+		await this.sonarLifecycle.start();
+		// Wait a moment for daemon to initialize
+		await new Promise((resolve) => setTimeout(resolve, 1000));
+	}
+
+	/**
+	 * Stop Sonar Agent
+	 */
+	async stopSonarAgent(): Promise<void> {
+		await this.sonarLifecycle.stop();
+	}
+
 	/**
 	 * Check status of all daemons
 	 */
 	async checkAll(): Promise<{
 		vector: DaemonStatus;
 		watcher: DaemonStatus;
+		sonar: DaemonStatus;
 	}> {
-		const [vector, watcher] = await Promise.all([
+		const [vector, watcher, sonar] = await Promise.all([
 			this.checkVectorDaemon(),
 			this.checkFileWatcher(),
+			this.checkSonarAgent(),
 		]);
-		return { vector, watcher };
+		return { vector, watcher, sonar };
 	}
 
 	/**
 	 * Stop all daemons
 	 */
 	async stopAll(): Promise<void> {
-		await Promise.all([this.stopVectorDaemon(), this.stopFileWatcher()]);
+		await Promise.all([
+			this.stopVectorDaemon(),
+			this.stopFileWatcher(),
+			this.stopSonarAgent(),
+		]);
 	}
 }