amalfa 1.0.28 → 1.0.30

package/src/daemon/sonar-strategies.ts

@@ -0,0 +1,187 @@
+import { loadConfig } from "@src/config/defaults";
+import { getLogger } from "@src/utils/Logger";
+import { callOllama, inferenceState } from "./sonar-inference";
+import type { SonarTask } from "./sonar-types";
+
+const log = getLogger("SonarStrategies");
+
+/**
+ * Get the recommended model for a task based on configuration
+ */
+export async function getTaskModel(
+	taskType: string,
+): Promise<string | undefined> {
+	const config = await loadConfig();
+	const useCloud = config.sonar.cloud?.enabled === true;
+	const provider = config.sonar.cloud?.provider || "ollama";
+
+	if (useCloud && provider === "openrouter") {
+		const models: Record<string, string> = {
+			garden: "google/gemini-2.0-flash-exp:free",
+			synthesis: "google/gemini-2.0-flash-exp:free",
+			timeline: "google/gemini-2.0-flash-exp:free",
+			research: "google/gemini-2.0-flash-exp:free",
+		};
+		return models[taskType];
+	}
+
+	return undefined;
+}
+
+/**
+ * Strategy 1: The "Judge"
+ * Verifies if two nodes should actually be linked and classifies the relationship.
+ */
+export async function judgeRelationship(
+	source: { id: string; content: string },
+	target: { id: string; content: string },
+	model?: string,
+): Promise<{ related: boolean; type?: string; reason?: string }> {
+	if (!inferenceState.ollamaAvailable) return { related: false };
+
+	try {
+		const response = await callOllama(
+			[
+				{
+					role: "system",
+					content: `You are a Semantic Graph Architect. Analyze two markdown notes and determine if they share a direct, non-trivial logical relationship.
+Possible Relationship Types:
+- EXTENDS: One note provides more detail or a follow-up to the other.
+- SUPPORTS: One note provides evidence or arguments for the other.
+- CONTRADICTS: Notes present opposing views or conflict.
+- REFERENCES: A general citation or mention without a strong logical link.
+- DUPLICATE: Notes cover significantly the same information.
+
+Guidelines:
+- Return JSON.
+- relate: boolean (true if a link is justified)
+- type: string (the uppercase relation type)
+- reason: string (brief explanation)
+
+If the link is trivial (e.g. just common words), set relate: false.`,
+				},
+				{
+					role: "user",
+					content: `Node A (ID: ${source.id}):\n${source.content.slice(0, 1500)}\n\n---\n\nNode B (ID: ${target.id}):\n${target.content.slice(0, 1500)}`,
+				},
+			],
+			{
+				temperature: 0.1,
+				format: "json",
+				model,
+			},
+		);
+
+		const result = JSON.parse(response.message.content);
+		return {
+			related: !!result.relate,
+			type: result.type?.toUpperCase(),
+			reason: result.reason,
+		};
+	} catch (error) {
+		log.warn({ error }, "LLM Judging failed");
+		return { related: false };
+	}
+}
+
+/**
+ * Strategy 2: Community Synthesis
+ * Summarizes a group of related nodes.
+ */
+export async function summarizeCommunity(
+	nodes: { id: string; content: string }[],
+	model?: string,
+): Promise<{ label: string; summary: string }> {
+	if (!inferenceState.ollamaAvailable)
+		return { label: "Synthesis", summary: "LLM Not available" };
+
+	try {
+		const response = await callOllama(
+			[
+				{
+					role: "system",
+					content: `You are a Knowledge Architect. Analyze a cluster of related documents and generate a canonical Label and a concise Synthesis (3 sentences max).
+The Label should be a clear topic name (e.g. "MCP Authentication Protocols").
+The Synthesis should explain the core theme connecting these documents.
+
+Return JSON format: { "label": "string", "summary": "string" }`,
+				},
+				{
+					role: "user",
+					content: nodes
+						.map((n) => `Node ${n.id}:\n${n.content.slice(0, 1000)}`)
+						.join("\n\n---\n\n"),
+				},
+			],
+			{
+				temperature: 0.3,
+				format: "json",
+				model,
+			},
+		);
+
+		const content = response.message.content;
+		try {
+			// Extract JSON if it's wrapped in code blocks
+			const jsonMatch = content.match(/```json\n([\s\S]*?)\n```/) || [
+				null,
+				content,
+			];
+			const jsonStr = jsonMatch[1] || content;
+			return JSON.parse(jsonStr);
+		} catch (error) {
+			log.warn({ error, content }, "Failed to parse community summary JSON");
+			throw error;
+		}
+	} catch (error) {
+		log.warn(
+			{ error: error instanceof Error ? error.message : String(error) },
+			"Community summary failed",
+		);
+		return { label: "Untitled Cluster", summary: "Failed to generate summary" };
+	}
+}
+
+/**
+ * Strategy 3: Chronos
+ * Extracts the primary temporal anchor from a document.
+ */
+export async function extractDate(
+	nodeId: string,
+	content: string,
+	model?: string,
+): Promise<string | null> {
+	// First try regex for common patterns
+	const dateMatch =
+		content.match(/Date:\*\*\s*(\d{4}-\d{2}-\d{2})/i) ||
+		content.match(/date:\s*(\d{4}-\d{2}-\d{2})/i) ||
+		content.match(/#\s*(\d{4}-\d{2}-\d{2})/i);
+
+	if (dateMatch) return dateMatch[1] || null;
+
+	if (!inferenceState.ollamaAvailable) return null;
+
+	try {
+		const response = await callOllama(
+			[
+				{
+					role: "system",
+					content: `You are a Temporal Chronologist. Extract the primary creation or event date from the following markdown note. 
+Return only the date in YYYY-MM-DD format. If no specific date is found, return "null".`,
+				},
+				{
+					role: "user",
+					content: `Node: ${nodeId}\nContent:\n${content.slice(0, 2000)}`,
+				},
+			],
+			{ temperature: 0, model },
+		);
+
+		const result = response.message.content.trim();
+		log.info({ nodeId, result }, "LLM Chronos result");
+		if (result === "null" || !/^\d{4}-\d{2}-\d{2}$/.test(result)) return null;
+		return result;
+	} catch {
+		return null;
+	}
+}

package/src/daemon/sonar-types.ts

@@ -0,0 +1,68 @@
+/**
+ * Common types and interfaces for Sonar Agent
+ */
+
+export interface Message {
+	role: "system" | "user" | "assistant";
+	content: string;
+}
+
+export interface ChatSession {
+	id: string;
+	messages: Message[];
+	startedAt: Date;
+}
+
+export interface SonarTask {
+	type:
+		| "synthesis"
+		| "timeline"
+		| "enhance_batch"
+		| "garden"
+		| "research"
+		| "chat";
+	minSize?: number;
+	limit?: number;
+	autoApply?: boolean;
+	notify?: boolean;
+	query?: string;
+	model?: string;
+	sessionId?: string;
+	message?: string;
+}
+
+export interface RequestOptions {
+	temperature?: number;
+	num_predict?: number;
+	stream?: boolean;
+	format?: "json";
+	model?: string;
+}
+
+/**
+ * API Request Types
+ */
+export interface ChatRequest {
+	sessionId: string;
+	message: string;
+	model?: string;
+}
+
+export interface MetadataEnhanceRequest {
+	docId: string;
+}
+
+export interface SearchAnalyzeRequest {
+	query: string;
+}
+
+export interface SearchRerankRequest {
+	results: Array<{ id: string; content: string; score: number }>;
+	query: string;
+	intent?: string;
+}
+
+export interface SearchContextRequest {
+	result: { id: string; content: string };
+	query: string;
+}

package/src/mcp/index.ts

@@ -112,6 +112,7 @@ async function runServer() {
 		EXPLORE: "explore_links",
 		LIST: "list_directory_structure",
 		GARDEN: "inject_tags",
+		GAPS: "find_gaps",
 	};
 
 	// 3. Register Handlers
@@ -158,16 +159,15 @@ async function runServer() {
 					inputSchema: { type: "object", properties: {} },
 				},
 				{
-					name: TOOLS.GARDEN,
+					name: TOOLS.GAPS,
 					description:
-						"Inject semantic tags into a source file (Gardener Agent).",
+						"Find semantic gaps (documents that are similar but not linked) in the knowledge graph.",
 					inputSchema: {
 						type: "object",
 						properties: {
-							file_path: { type: "string" },
-							tags: { type: "array", items: { type: "string" } },
+							limit: { type: "number", default: 10 },
+							threshold: { type: "number", default: 0.8 },
 						},
-						required: ["file_path", "tags"],
 					},
 				},
 			],
@@ -407,6 +407,21 @@ async function runServer() {
 				};
 			}
 
+			if (name === TOOLS.GAPS) {
+				const limit = Number(args?.limit || 10);
+				try {
+					const gaps = await sonarClient.getGaps(limit);
+					return {
+						content: [{ type: "text", text: JSON.stringify(gaps, null, 2) }],
+					};
+				} catch (e) {
+					return {
+						content: [{ type: "text", text: `Failed to fetch gaps: ${e}` }],
+						isError: true,
+					};
+				}
+			}
+
 			if (name === TOOLS.GARDEN) {
 				const filePath = String(args?.file_path);
 				const tags = args?.tags as string[];

package/src/pipeline/AmalfaIngestor.ts

@@ -181,7 +181,7 @@ export class AmalfaIngestor {
 	 */
 	private async discoverFiles(): Promise<string[]> {
 		const files: string[] = [];
-		const glob = new Glob("**/*.md");
+		const glob = new Glob("**/*.{md,ts,js}");
 		const sources = this.config.sources || ["./docs"];
 
 		// Scan each source directory
@@ -245,7 +245,7 @@ export class AmalfaIngestor {
 			// Generate ID from filename
 			const filename = filePath.split("/").pop() || "unknown";
 			const id = filename
-				.replace(".md", "")
+				.replace(/\.(md|ts|js)$/, "")
 				.toLowerCase()
 				.replace(/[^a-z0-9-]/g, "-");
 

package/src/resonance/db.ts

@@ -16,6 +16,7 @@ export interface Node {
 	embedding?: Float32Array;
 	hash?: string;
 	meta?: Record<string, unknown>; // JSON object for flexible metadata
+	date?: string; // ISO-8601 or similar temporal anchor
 }
 
 export class ResonanceDB {
@@ -107,8 +108,8 @@ export class ResonanceDB {
 		// Schema v6: content column deprecated, always set to NULL
 		// Content is read from filesystem via meta.source
 		const stmt = this.db.prepare(`
-            INSERT OR REPLACE INTO nodes (id, type, title, content, domain, layer, embedding, hash, meta)
-            VALUES ($id, $type, $title, NULL, $domain, $layer, $embedding, $hash, $meta)
+            INSERT OR REPLACE INTO nodes (id, type, title, content, domain, layer, embedding, hash, meta, date)
+            VALUES ($id, $type, $title, NULL, $domain, $layer, $embedding, $hash, $meta, $date)
         `);
 
 		try {
@@ -132,6 +133,7 @@ export class ResonanceDB {
 				$embedding: blob,
 				$hash: node.hash ? String(node.hash) : null,
 				$meta: node.meta ? JSON.stringify(node.meta) : null,
+				$date: node.date ? String(node.date) : null,
 			});
 		} catch (err) {
 			log.error(
@@ -244,6 +246,10 @@ export class ResonanceDB {
 		return rows.map((row) => this.mapRowToNode(row));
 	}
 
+	updateNodeDate(id: string, date: string) {
+		this.db.run("UPDATE nodes SET date = ? WHERE id = ?", [date, id]);
+	}
+
 	getLexicon(): {
 		id: string;
 		label: string;
@@ -293,6 +299,7 @@ export class ResonanceDB {
 				: undefined,
 			hash: row.hash,
 			meta: row.meta ? JSON.parse(row.meta) : {},
+			date: row.date,
 		};
 	}
 

package/src/resonance/schema.ts

@@ -1,4 +1,4 @@
-export const CURRENT_SCHEMA_VERSION = 6;
+export const CURRENT_SCHEMA_VERSION = 7;
 
 export const GENESIS_SQL = `
     CREATE TABLE IF NOT EXISTS nodes (
@@ -9,7 +9,8 @@ export const GENESIS_SQL = `
         layer TEXT,
         embedding BLOB,
         hash TEXT, 
-        meta TEXT
+        meta TEXT,
+        date TEXT
     );
     
     CREATE TABLE IF NOT EXISTS edges (
@@ -153,4 +154,16 @@ export const MIGRATIONS: Migration[] = [
 			);
 		},
 	},
+	{
+		version: 7,
+		description: "Add 'date' column for temporal grounding",
+		up: (db) => {
+			try {
+				db.run("ALTER TABLE nodes ADD COLUMN date TEXT");
+			} catch (e: unknown) {
+				const err = e as { message: string };
+				if (!err.message.includes("duplicate column")) throw e;
+			}
+		},
+	},
 ];

package/src/utils/TagInjector.ts

@@ -0,0 +1,90 @@
+import { readFileSync, writeFileSync, existsSync } from "node:fs";
+import { getLogger } from "@src/utils/Logger";
+
+const log = getLogger("TagInjector");
+
+/**
+ * TagInjector - Utility for safely injecting semantic tags and links into markdown files.
+ * Supports FAFCAS-compliant tag syntax.
+ */
+export class TagInjector {
+	/**
+	 * Injects a semantic tag into a markdown file.
+	 * If the file has frontmatter, it appends to the frontmatter.
+	 * Otherwise, it adds a tag block at the top.
+	 */
+	static injectTag(
+		filePath: string,
+		relation: string,
+		targetId: string,
+	): boolean {
+		if (!existsSync(filePath)) {
+			log.error({ filePath }, "File not found for tag injection");
+			return false;
+		}
+
+		try {
+			let content = readFileSync(filePath, "utf-8");
+			const tagString = `[${relation.toUpperCase()}: ${targetId}]`;
+
+			// Check if tag already exists to avoid duplicates
+			if (content.includes(tagString)) {
+				return true;
+			}
+
+			// Look for existing tag block: <!-- tags: ... -->
+			const tagBlockRegex = /<!-- tags: (.*?) -->/;
+			const match = content.match(tagBlockRegex);
+
+			if (match) {
+				// Append to existing block
+				const oldBlock = match[0];
+				const innerTags = match[1];
+				const newBlock = `<!-- tags: ${innerTags} ${tagString} -->`;
+				content = content.replace(oldBlock, newBlock);
+			} else {
+				// Create new block after frontmatter or at top
+				const frontmatterRegex = /^---\n[\s\S]*?\n---\n/;
+				const fmMatch = content.match(frontmatterRegex);
+				const newTagBlock = `\n<!-- tags: ${tagString} -->\n`;
+
+				if (fmMatch) {
+					content = content.replace(fmMatch[0], fmMatch[0] + newTagBlock);
+				} else {
+					content = newTagBlock + content;
+				}
+			}
+
+			writeFileSync(filePath, content, "utf-8");
+			return true;
+		} catch (error) {
+			log.error({ error, filePath }, "Failed to inject tag");
+			return false;
+		}
+	}
+
+	/**
+	 * Injects a WikiLink into the end of a markdown file.
+	 */
+	static injectLink(
+		filePath: string,
+		targetId: string,
+		label?: string,
+	): boolean {
+		if (!existsSync(filePath)) return false;
+
+		try {
+			let content = readFileSync(filePath, "utf-8");
+			const link = label ? `[[${targetId}|${label}]]` : `[[${targetId}]]`;
+
+			if (content.includes(link)) return true;
+
+			content = content.trimEnd() + `\n\nSee also: ${link}\n`;
+			writeFileSync(filePath, content, "utf-8");
+			return true;
+		} catch (error) {
+			log.error({ error, filePath }, "Failed to inject link");
+			return false;
+		}
+	}
+}

package/src/utils/sonar-client.ts

@@ -35,6 +35,7 @@ export interface SonarClient {
 		result: { id: string; content: string },
 		query: string,
 	): Promise<{ snippet: string; context: string; confidence: number } | null>;
+	getGaps(limit?: number): Promise<any[]>;
 }
 
 /**
@@ -255,6 +256,19 @@ export async function createSonarClient(): Promise<SonarClient> {
 				return null;
 			}
 		},
+
+		async getGaps(limit?: number): Promise<any[]> {
+			if (!(await isAvailable())) return [];
+			try {
+				const response = await fetch(`${baseUrl}/graph/explore`);
+				if (!response.ok) return [];
+				const data = (await response.json()) as { gaps?: any[] };
+				return data.gaps || [];
+			} catch (error) {
+				log.error({ error }, "Failed to fetch gaps");
+				return [];
+			}
+		},
 	};
 }
 
@@ -290,5 +304,8 @@ function createDisabledClient(): SonarClient {
 		} | null> {
 			return null;
 		},
+		async getGaps(): Promise<any[]> {
+			return [];
+		},
 	};
 }