amalfa 1.0.19 → 1.0.23

package/src/mcp/index.ts

@@ -1,5 +1,5 @@
-import { appendFileSync } from "node:fs";
-import { join } from "node:path";
+import { appendFileSync } from "fs";
+import { join } from "path";
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import {
@@ -8,18 +8,21 @@ import {
 	ListToolsRequestSchema,
 	ReadResourceRequestSchema,
 } from "@modelcontextprotocol/sdk/types.js";
-import { loadConfig } from "@src/config/defaults";
+import { AMALFA_DIRS, loadConfig } from "@src/config/defaults";
 import { VectorEngine } from "@src/core/VectorEngine";
 import { ResonanceDB } from "@src/resonance/db";
 import { DaemonManager } from "../utils/DaemonManager";
 import { getLogger } from "../utils/Logger";
 import { ServiceLifecycle } from "../utils/ServiceLifecycle";
-import { AMALFA_DIRS } from "@src/config/defaults";
+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({
@@ -182,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) {
@@ -199,6 +231,7 @@ async function runServer() {
 								score: r.score,
 								preview: preview,
 								source: "vector",
+								content: r.content || "",
 							});
 						}
 					} catch (e: unknown) {
@@ -207,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");
+					}
 
-					if (results.length === 0 && errors.length > 0) {
+					// 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 (finalResults.length === 0 && errors.length > 0) {
 						return {
 							content: [
 								{ type: "text", text: `Search Error: ${errors.join(", ")}` },
@@ -220,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
@@ -296,10 +401,7 @@ async function runServer() {
 
 			if (name === TOOLS.LIST) {
 				// TODO: Make this configurable via amalfa.config.ts
-				const structure = [
-					"docs/",
-					"notes/",
-				];
+				const structure = ["docs/", "notes/"];
 				return {
 					content: [{ type: "text", text: JSON.stringify(structure, null, 2) }],
 				};
@@ -308,17 +410,37 @@ async function runServer() {
 			if (name === TOOLS.GARDEN) {
 				const filePath = String(args?.file_path);
 				const tags = args?.tags as string[];
-				const content = await Bun.file(filePath).text();
-				const tagBlock = `\n<!-- tags: ${tags.join(", ")} -->\n`;
-				const newContent = content.endsWith("\n")
-					? content + tagBlock
-					: `${content}\n${tagBlock}`;
-				await Bun.write(filePath, newContent);
+				let content = await Bun.file(filePath).text();
+
+				// Check for existing tag block and merge/replace
+				const tagPattern = /<!-- tags: ([^>]+) -->\s*$/;
+				const match = content.match(tagPattern);
+
+				let operation = "injected";
+				if (match?.[1]) {
+					// Merge with existing tags
+					const existingTags = match[1]
+						.split(",")
+						.map((t) => t.trim())
+						.filter(Boolean);
+					const mergedTags = [...new Set([...existingTags, ...tags])]; // deduplicate
+					const tagBlock = `<!-- tags: ${mergedTags.join(", ")} -->`;
+					content = content.replace(tagPattern, `${tagBlock}\n`);
+					operation = "merged";
+				} else {
+					// Append new tag block
+					const tagBlock = `<!-- tags: ${tags.join(", ")} -->`;
+					content = content.endsWith("\n")
+						? `${content}\n${tagBlock}\n`
+						: `${content}\n\n${tagBlock}\n`;
+				}
+
+				await Bun.write(filePath, content);
 				return {
 					content: [
 						{
 							type: "text",
-							text: `Injected ${tags.length} tags into ${filePath}`,
+							text: `Successfully ${operation} ${tags.length} tags into ${filePath}`,
 						},
 					],
 				};
@@ -394,4 +516,4 @@ process.on("unhandledRejection", (reason) => {
 
 // --- Dispatch ---
 
-await lifecycle.run(command, runServer, false);
+await lifecycle.run(command, runServer);

package/src/pipeline/AmalfaIngestor.ts

@@ -4,14 +4,14 @@
  * No Persona/CDA complexity - just pure markdown → knowledge graph
  */
 
-import { join } from "node:path";
-import { Glob } from "bun";
+import { join } from "path";
 import type { AmalfaConfig } from "@src/config/defaults";
 import { EdgeWeaver } from "@src/core/EdgeWeaver";
-import { ResonanceDB, type Node } from "@src/resonance/db";
+import type { Node, ResonanceDB } from "@src/resonance/db";
 import { Embedder } from "@src/resonance/services/embedder";
 import { SimpleTokenizerService as TokenizerService } from "@src/resonance/services/simpleTokenizer";
 import { getLogger } from "@src/utils/Logger";
+import { Glob } from "bun";
 
 export interface IngestionResult {
 	success: boolean;
@@ -37,7 +37,7 @@ export class AmalfaIngestor {
 	 */
 	async ingest(): Promise<IngestionResult> {
 		const startTime = performance.now();
-		
+
 		const sources = this.config.sources || ["./docs"];
 		this.log.info(`📚 Starting ingestion from: ${sources.join(", ")}`);
 
@@ -47,7 +47,7 @@ export class AmalfaIngestor {
 			await embedder.embed("init"); // Warm up
 
 			const tokenizer = TokenizerService.getInstance();
-			
+
 			// Discover markdown files
 			const files = await this.discoverFiles();
 			this.log.info(`📁 Found ${files.length} markdown files`);
@@ -108,7 +108,10 @@ export class AmalfaIngestor {
 				if (!filePath) continue;
 				const content = await Bun.file(filePath).text();
 				const filename = filePath.split("/").pop() || "unknown";
-				const id = filename.replace(".md", "").toLowerCase().replace(/[^a-z0-9-]/g, "-");
+				const id = filename
+					.replace(".md", "")
+					.toLowerCase()
+					.replace(/[^a-z0-9-]/g, "-");
 				weaver.weave(id, content);
 			}
 			this.db.commit();
@@ -117,17 +120,36 @@ export class AmalfaIngestor {
 			this.log.info("💾 Forcing WAL checkpoint...");
 			this.db.getRawDb().run("PRAGMA wal_checkpoint(TRUNCATE);");
 
+			// OH-104: The Pinch Check (verify physical commit)
+			const dbPath = this.db.getRawDb().filename;
+			const dbFile = Bun.file(dbPath);
+			if (!(await dbFile.exists())) {
+				throw new Error(
+					"OH-104 VIOLATION: Database file missing after checkpoint",
+				);
+			}
+			const finalSize = dbFile.size;
+			if (finalSize === 0) {
+				throw new Error(
+					"OH-104 VIOLATION: Database file is empty after checkpoint",
+				);
+			}
+			this.log.info(`✅ Pinch Check: db=${(finalSize / 1024).toFixed(1)}KB`);
+
 			const endTime = performance.now();
 			const durationSec = (endTime - startTime) / 1000;
 
 			const stats = this.db.getStats();
-			this.log.info({
-				files: processedCount,
-				nodes: stats.nodes,
-				edges: stats.edges,
-				vectors: stats.vectors,
-				durationSec: durationSec.toFixed(2),
-			}, "✅ Ingestion complete");
+			this.log.info(
+				{
+					files: processedCount,
+					nodes: stats.nodes,
+					edges: stats.edges,
+					vectors: stats.vectors,
+					durationSec: durationSec.toFixed(2),
+				},
+				"✅ Ingestion complete",
+			);
 
 			return {
 				success: true,
@@ -178,7 +200,10 @@ export class AmalfaIngestor {
 					}
 				}
 			} catch (e) {
-				this.log.warn({ source: sourcePath, err: e }, "⚠️  Failed to scan directory");
+				this.log.warn(
+					{ source: sourcePath, err: e },
+					"⚠️  Failed to scan directory",
+				);
 			}
 		}
 
@@ -215,9 +240,7 @@ export class AmalfaIngestor {
 
 			// Parse frontmatter
 			const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
-			const frontmatter = fmMatch?.[1]
-				? this.parseFrontmatter(fmMatch[1])
-				: {};
+			const frontmatter = fmMatch?.[1] ? this.parseFrontmatter(fmMatch[1]) : {};
 
 			// Generate ID from filename
 			const filename = filePath.split("/").pop() || "unknown";

package/src/pipeline/PreFlightAnalyzer.ts

@@ -10,8 +10,8 @@
  * Generates .amalfa/logs/pre-flight.log with recommendations.
  */
 
-import { existsSync, lstatSync, readdirSync, realpathSync, statSync, writeFileSync } from "node:fs";
-import { join, relative } from "node:path";
+import { existsSync, lstatSync, readdirSync, realpathSync, statSync, writeFileSync } from "fs";
+import { join, relative } from "path";
 import { getLogger } from "@src/utils/Logger";
 import type { AmalfaConfig } from "@src/config/defaults";
 import { AMALFA_DIRS, initAmalfaDirs } from "@src/config/defaults";

package/src/pipeline/SemanticHarvester.ts

@@ -10,8 +10,8 @@
  * await harvester.loadIntoResonance(graph);
  */
 
-import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync } from "fs";
+import { join } from "path";
 import { getLogger } from "@src/utils/Logger";
 import { $ } from "bun";
 

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/resonance/services/embedder.ts

@@ -1,4 +1,4 @@
-import { join } from "node:path";
+import { join } from "path";
 import { toFafcas } from "@src/resonance/db";
 import { EmbeddingModel, FlagEmbedding } from "fastembed";
 

package/src/resonance/services/vector-daemon.ts

@@ -5,7 +5,7 @@
  */
 
 import { serve } from "bun";
-import { join } from "node:path";
+import { join } from "path";
 import { EmbeddingModel, FlagEmbedding } from "fastembed";
 import { toFafcas } from "@src/resonance/db";
 import { getLogger } from "@src/utils/Logger";

package/src/utils/DaemonManager.ts

@@ -1,5 +1,5 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { existsSync } from "fs";
+import { join } from "path";
 import { ServiceLifecycle } from "./ServiceLifecycle";
 import { AMALFA_DIRS } from "@src/config/defaults";
 
@@ -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(),
+		]);
 	}
 }

package/src/utils/Notifications.ts

@@ -1,5 +1,5 @@
-import { spawn } from "node:child_process";
-import { platform } from "node:os";
+import { spawn } from "child_process";
+import { platform } from "os";
 
 /**
  * Send a native desktop notification