amalfa 1.0.0 → 1.0.2

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

@@ -0,0 +1,151 @@
+#!/usr/bin/env bun
+/**
+ * Vector Daemon - HTTP server for fast embedding generation
+ * Keeps FastEmbed model loaded in memory for <100ms embedding lookups
+ */
+
+import { serve } from "bun";
+import { EmbeddingModel, FlagEmbedding } from "fastembed";
+import { toFafcas } from "@src/resonance/db";
+import { getLogger } from "@src/utils/Logger";
+import { ServiceLifecycle } from "@src/utils/ServiceLifecycle";
+
+const log = getLogger("VectorDaemon");
+const PORT = Number(process.env.VECTOR_PORT || 3010);
+
+// Service lifecycle management
+const lifecycle = new ServiceLifecycle({
+	name: "Vector-Daemon",
+	pidFile: ".vector-daemon.pid",
+	logFile: ".vector-daemon.log",
+	entryPoint: "src/resonance/services/vector-daemon.ts",
+});
+
+// Keep model loaded in memory
+let embedder: FlagEmbedding | null = null;
+const currentModel = EmbeddingModel.BGESmallENV15;
+
+/**
+ * Initialize embedding model (called once at startup)
+ */
+async function initEmbedder() {
+	if (!embedder) {
+		log.info({ model: currentModel }, "🔄 Initializing embedding model...");
+		
+		// Ensure cache directory exists
+		const cacheDir = ".resonance/cache";
+		const { mkdir } = await import("node:fs/promises");
+		try {
+			await mkdir(cacheDir, { recursive: true });
+		} catch (e) {
+			// Directory might already exist, that's fine
+		}
+		
+		embedder = await FlagEmbedding.init({
+			model: currentModel,
+			cacheDir,
+			showDownloadProgress: true,
+		});
+		log.info("✅ Embedding model loaded and ready");
+	}
+}
+
+/**
+ * Main server logic
+ */
+async function runServer() {
+	// Initialize model before accepting requests
+	await initEmbedder();
+
+	// Start HTTP server
+	const server = serve({
+		port: PORT,
+		async fetch(req) {
+			const url = new URL(req.url);
+
+			// Health check endpoint
+			if (url.pathname === "/health") {
+				return new Response(
+					JSON.stringify({
+						status: "ok",
+						model: currentModel,
+						ready: embedder !== null,
+					}),
+					{
+						headers: { "Content-Type": "application/json" },
+					},
+				);
+			}
+
+			// Embed endpoint
+			if (url.pathname === "/embed" && req.method === "POST") {
+				try {
+					const body = (await req.json()) as { text?: string; model?: string };
+					const { text } = body;
+
+					if (!text) {
+						return new Response(
+							JSON.stringify({ error: "Missing text parameter" }),
+							{
+								status: 400,
+								headers: { "Content-Type": "application/json" },
+							},
+						);
+					}
+
+					// Generate embedding
+					if (!embedder) {
+						throw new Error("Embedder not initialized");
+					}
+
+					const gen = embedder.embed([text]);
+					const result = await gen.next();
+					const val = result.value?.[0];
+
+					if (!val || val.length === 0) {
+						throw new Error("Embedding generation returned empty result");
+					}
+
+					// Normalize using FAFCAS protocol
+					const raw = new Float32Array(val);
+					const normalized = toFafcas(raw);
+
+					// Convert to plain array for JSON serialization
+					const vector = Array.from(new Float32Array(normalized.buffer));
+
+					return new Response(
+						JSON.stringify({
+							vector,
+							dimensions: vector.length,
+						}),
+						{
+							headers: { "Content-Type": "application/json" },
+						},
+					);
+				} catch (e) {
+					log.error({ err: e }, "❌ Embedding generation failed");
+					return new Response(
+						JSON.stringify({
+							error: e instanceof Error ? e.message : String(e),
+						}),
+						{
+							status: 500,
+							headers: { "Content-Type": "application/json" },
+						},
+					);
+				}
+			}
+
+			// 404 for unknown endpoints
+			return new Response("Not Found", { status: 404 });
+		},
+	});
+
+	log.info({ port: PORT, model: currentModel }, "🚀 Vector Daemon listening");
+
+	// Keep server alive
+	await new Promise(() => {});
+}
+
+// Run with lifecycle management
+await lifecycle.run(process.argv[2] || "serve", runServer);

package/src/utils/DaemonManager.ts

@@ -0,0 +1,147 @@
+import { existsSync } from "node:fs";
+import { ServiceLifecycle } from "./ServiceLifecycle";
+
+export interface DaemonStatus {
+	running: boolean;
+	pid?: number;
+	port?: number;
+}
+
+/**
+ * DaemonManager - Unified management for AMALFA daemons
+ * Handles vector daemon and file watcher daemon
+ */
+export class DaemonManager {
+	private vectorLifecycle: ServiceLifecycle;
+	private watcherLifecycle: ServiceLifecycle;
+
+	constructor() {
+		this.vectorLifecycle = new ServiceLifecycle({
+			name: "Vector-Daemon",
+			pidFile: ".vector-daemon.pid",
+			logFile: ".vector-daemon.log",
+			entryPoint: "src/resonance/services/vector-daemon.ts",
+		});
+
+		this.watcherLifecycle = new ServiceLifecycle({
+			name: "File-Watcher",
+			pidFile: ".amalfa-daemon.pid",
+			logFile: ".amalfa-daemon.log",
+			entryPoint: "src/daemon/index.ts",
+		});
+	}
+
+	/**
+	 * Check if a process is running
+	 */
+	private async isProcessRunning(pid: number): Promise<boolean> {
+		try {
+			process.kill(pid, 0);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+
+	/**
+	 * Read PID from file
+	 */
+	private async readPid(pidFile: string): Promise<number | null> {
+		if (!existsSync(pidFile)) {
+			return null;
+		}
+		try {
+			const content = await Bun.file(pidFile).text();
+			const pid = Number.parseInt(content.trim(), 10);
+			return Number.isNaN(pid) ? null : pid;
+		} catch {
+			return null;
+		}
+	}
+
+	/**
+	 * Check if vector daemon is running
+	 */
+	async checkVectorDaemon(): Promise<DaemonStatus> {
+		const pid = await this.readPid(".vector-daemon.pid");
+		if (!pid) {
+			return { running: false };
+		}
+
+		const running = await this.isProcessRunning(pid);
+		return {
+			running,
+			pid: running ? pid : undefined,
+			port: running ? 3010 : undefined,
+		};
+	}
+
+	/**
+	 * Start vector daemon
+	 */
+	async startVectorDaemon(): Promise<void> {
+		await this.vectorLifecycle.start();
+		// Wait a moment for daemon to initialize
+		await new Promise((resolve) => setTimeout(resolve, 1000));
+	}
+
+	/**
+	 * Stop vector daemon
+	 */
+	async stopVectorDaemon(): Promise<void> {
+		await this.vectorLifecycle.stop();
+	}
+
+	/**
+	 * Check if file watcher daemon is running
+	 */
+	async checkFileWatcher(): Promise<DaemonStatus> {
+		const pid = await this.readPid(".amalfa-daemon.pid");
+		if (!pid) {
+			return { running: false };
+		}
+
+		const running = await this.isProcessRunning(pid);
+		return {
+			running,
+			pid: running ? pid : undefined,
+		};
+	}
+
+	/**
+	 * Start file watcher daemon
+	 */
+	async startFileWatcher(): Promise<void> {
+		await this.watcherLifecycle.start();
+		// Wait a moment for daemon to initialize
+		await new Promise((resolve) => setTimeout(resolve, 500));
+	}
+
+	/**
+	 * Stop file watcher daemon
+	 */
+	async stopFileWatcher(): Promise<void> {
+		await this.watcherLifecycle.stop();
+	}
+
+	/**
+	 * Check status of all daemons
+	 */
+	async checkAll(): Promise<{
+		vector: DaemonStatus;
+		watcher: DaemonStatus;
+	}> {
+		const [vector, watcher] = await Promise.all([
+			this.checkVectorDaemon(),
+			this.checkFileWatcher(),
+		]);
+		return { vector, watcher };
+	}
+
+	/**
+	 * Stop all daemons
+	 */
+	async stopAll(): Promise<void> {
+		await Promise.all([this.stopVectorDaemon(), this.stopFileWatcher()]);
+	}
+}

package/src/utils/ZombieDefense.ts

@@ -12,8 +12,12 @@ export interface ZombieReport {
 
 // Services intended to run as singletons
 const WHITELIST = [
-	"src/resonance/daemon.ts",
+	// AMALFA core services
 	"src/mcp/index.ts",
+	"src/resonance/services/vector-daemon.ts",
+	"src/daemon/index.ts",
+	// Legacy services
+	"src/resonance/daemon.ts",
 	"scripts/cli/dev.ts",
 	"src/resonance/cli/ingest.ts",
 	"bun run build:data",

package/README.old.md

@@ -1,112 +0,0 @@
-# Polyvis: A Neuro-Symbolic Graph Visualizer
-
-Polyvis is a lightweight, frontend-only web application for exploring and visualizing neuro-symbolic knowledge graphs. It renders conceptual relationships from a pre-built SQLite database, allowing users to navigate a "Neuro-Map" of interconnected ideas, principles, and directives.
-
-The application is built with HTML, CSS, and [Alpine.js](https://alpinejs.dev/), and uses [Bun](https://bun.sh/) as its JavaScript runtime and toolkit. The graph visualization is powered by [viz.js](https://github.com/mdaines/viz.js) and [Sigma.js](https://www.sigmajs.org/), and the in-browser database is handled by [sql.js](https://sql.js.org/).
-
-## Features
-
-- **Interactive Graph Visualization:** Explore the knowledge graph by searching for terms.
-- **Data-Driven Suggestions:** The search box provides a curated list of high-value terms guaranteed to produce rich, interesting graphs.
-- **In-Browser Database:** The entire graph dataset is loaded into the browser via sql.js, requiring no active backend server for querying.
-- **Alpine.js Reactivity:** Uses [Alpine.js](https://alpinejs.dev/) for a lightweight, reactive UI without a complex build step.
-- **Zero-Build Frontend:** Built with vanilla web technologies and Alpine.js for maximum simplicity and performance.
-- **Themable UI:** All design tokens (colors, dimensions) are centralized in `src/css/layers/theme.css` ("The Control Panel") for easy customization.
-- **Semantic Styling:** No magic numbers. All styles use semantic variables (e.g., `--surface-panel`, `--border-base`) for consistent theming.
-- **Efficient Search:** Two-tier search architecture (vector embeddings + grep) - no FTS or chunking needed.
-
-## Search Architecture
-
-Polyvis uses a **two-tier search system** that eliminates the need for full-text search (FTS) or document chunking:
-
-### 1. Vector Search (Semantic)
-- **Purpose:** Semantic similarity, concept discovery
-- **Accuracy:** 85% average best match across diverse queries
-- **Speed:** <10ms per query
-- **Use case:** "Find documents about CSS patterns" or "Show me graph weaving logic"
-
-### 2. Grep/Ripgrep (Literal)
-- **Purpose:** Exact phrase matches, symbol lookup
-- **Accuracy:** 100% (literal text matching)
-- **Speed:** <1ms
-- **Use case:** "Find exact phrase 'function fooBar'" or "Where is BentoBoxer imported?"
-
-### Why No Chunking?
-
-**Document corpus characteristics:**
-- 80% of documents are <5KB (~1,000 words) - already "chunk-sized"
-- Average document: 2.7KB (~550 words)
-- Largest document: 47KB (~9,500 words) - still within LLM context windows
-
-**Results without chunking:**
-- Vector search achieves 85% accuracy on whole documents
-- Documents are well-structured markdown with clear headers
-- Natural granularity matches search needs
-
-**Future strategy:** If large documents (>20KB) become problematic, split them into multiple markdown files at natural boundaries (H1/H2 headers) and commit to version control. This keeps source files as the source of truth, maintains git-friendly diffs, and requires no runtime infrastructure.
-
-**See:** `docs/BENTO_BOXING_DEPRECATION.md` for full analysis and decision rationale.
-
-## Design System (The Control Center)
-The application's visual design is strictly controlled by **`src/css/layers/theme.css`**. This file acts as a configuration panel for:
--   **Dimensions:** Sidebar widths, header heights.
--   **Colors:** Semantic mappings (e.g., `--surface-1`, `--brand`).
--   **Spacing:** Global padding and gaps.
-
-**Protocol:** Always check and tweak `theme.css` before modifying component styles.
-
-## Prerequisites
-
-- [Bun.js](https://bun.sh/docs/installation) (v1.0 or later) - **MANDATORY**
-- A local web server for development (e.g., `bun x http-server`)
-
-## Getting Started
-
-Follow these steps to set up and run the project locally.
-
-### 1. Installation
-
-There are no external dependencies to install for the application itself, as it relies on vanilla JavaScript and CDN-hosted libraries.
-
-### 2. Development Workflow
-
-For detailed instructions on CSS development, database building, and running the app, please refer to the **[Development Workflow Playbook](playbooks/development-workflow-playbook.md)**.
-
-**Quick Start:**
-1.  **Dev Mode:** `bun run dev` (Starts server & CSS watcher)
-2.  **Build DB:** `bun run scripts/build_db.ts`
-
-## Project Structure
-
-### 3. Detailed Documentation
-For a deep dive on the codebase organization, please see **[Project Structure](docs/webdocs/project-structure.md)**.
-
-## Project Structure (High Level)
-
-```
-├── public/              # Web Root (HTML, Static Data)
-│   ├── explorer/        # Sigma.js Graph Explorer
-│   └── resonance.db     # SQLite Database (generated locally)
-│
-├── src/                 # Application Source Code
-│   ├── core/            # The Bento Box Kernel (Normalizer, Weaver)
-│   ├── config/          # Shared Configuration
-│   └── db/              # Database Schemas
-│
-├── scripts/             # Data Pipeline & Tooling
-│   ├── pipeline/        # ETL Scripts (Sync, Load)
-│   ├── cli/             # Command Line Tools (Harvest)
-│   └── verify/          # Integrity Checks
-│
-├── docs/                # Project Documentation
-├── playbooks/           # Operational Protocols
-├── polyvis.settings.json # Central Configuration
-└── README.md            # This file
-```
-
-## Contributing
-## Contribution Guidelines
-Please review `AGENTS.md` for our operational protocols, specifically:
--   **EVP (Empirical Verification Protocol):** Use the browser to verify, don't guess.
--   **GEP (Granular Execution Protocol):** One step at a time.
- Please feel free to open issues or submit pull requests.

package/agents.config.json

@@ -1,11 +0,0 @@
-{
-	"nanocoder": {
-		"providers": [
-			{
-				"name": "ollama",
-				"models": ["llama3.1:8b"],
-				"baseUrl": "http://localhost:11434/v1"
-			}
-		]
-	}
-}

package/drizzle/0000_minor_iron_fist.sql

@@ -1,19 +0,0 @@
-CREATE TABLE `edges` (
-	`source` text NOT NULL,
-	`target` text NOT NULL,
-	`type` text NOT NULL,
-	`metadata` text
-);
---> statement-breakpoint
-CREATE TABLE `nodes` (
-	`id` text PRIMARY KEY NOT NULL,
-	`type` text NOT NULL,
-	`title` text,
-	`content` text,
-	`domain` text DEFAULT 'knowledge',
-	`layer` text DEFAULT 'experience',
-	`order_index` integer DEFAULT 0,
-	`metadata` text,
-	`external_refs` text,
-	`embedding` blob
-);

package/drizzle/meta/0000_snapshot.json

@@ -1,139 +0,0 @@
-{
-	"version": "6",
-	"dialect": "sqlite",
-	"id": "96582325-8a88-4ffb-872a-43699e33324c",
-	"prevId": "00000000-0000-0000-0000-000000000000",
-	"tables": {
-		"edges": {
-			"name": "edges",
-			"columns": {
-				"source": {
-					"name": "source",
-					"type": "text",
-					"primaryKey": false,
-					"notNull": true,
-					"autoincrement": false
-				},
-				"target": {
-					"name": "target",
-					"type": "text",
-					"primaryKey": false,
-					"notNull": true,
-					"autoincrement": false
-				},
-				"type": {
-					"name": "type",
-					"type": "text",
-					"primaryKey": false,
-					"notNull": true,
-					"autoincrement": false
-				},
-				"metadata": {
-					"name": "metadata",
-					"type": "text",
-					"primaryKey": false,
-					"notNull": false,
-					"autoincrement": false
-				}
-			},
-			"indexes": {},
-			"foreignKeys": {},
-			"compositePrimaryKeys": {},
-			"uniqueConstraints": {},
-			"checkConstraints": {}
-		},
-		"nodes": {
-			"name": "nodes",
-			"columns": {
-				"id": {
-					"name": "id",
-					"type": "text",
-					"primaryKey": true,
-					"notNull": true,
-					"autoincrement": false
-				},
-				"type": {
-					"name": "type",
-					"type": "text",
-					"primaryKey": false,
-					"notNull": true,
-					"autoincrement": false
-				},
-				"title": {
-					"name": "title",
-					"type": "text",
-					"primaryKey": false,
-					"notNull": false,
-					"autoincrement": false
-				},
-				"content": {
-					"name": "content",
-					"type": "text",
-					"primaryKey": false,
-					"notNull": false,
-					"autoincrement": false
-				},
-				"domain": {
-					"name": "domain",
-					"type": "text",
-					"primaryKey": false,
-					"notNull": false,
-					"autoincrement": false,
-					"default": "'knowledge'"
-				},
-				"layer": {
-					"name": "layer",
-					"type": "text",
-					"primaryKey": false,
-					"notNull": false,
-					"autoincrement": false,
-					"default": "'experience'"
-				},
-				"order_index": {
-					"name": "order_index",
-					"type": "integer",
-					"primaryKey": false,
-					"notNull": false,
-					"autoincrement": false,
-					"default": 0
-				},
-				"metadata": {
-					"name": "metadata",
-					"type": "text",
-					"primaryKey": false,
-					"notNull": false,
-					"autoincrement": false
-				},
-				"external_refs": {
-					"name": "external_refs",
-					"type": "text",
-					"primaryKey": false,
-					"notNull": false,
-					"autoincrement": false
-				},
-				"embedding": {
-					"name": "embedding",
-					"type": "blob",
-					"primaryKey": false,
-					"notNull": false,
-					"autoincrement": false
-				}
-			},
-			"indexes": {},
-			"foreignKeys": {},
-			"compositePrimaryKeys": {},
-			"uniqueConstraints": {},
-			"checkConstraints": {}
-		}
-	},
-	"views": {},
-	"enums": {},
-	"_meta": {
-		"schemas": {},
-		"tables": {},
-		"columns": {}
-	},
-	"internal": {
-		"indexes": {}
-	}
-}

package/drizzle/meta/_journal.json

@@ -1,13 +0,0 @@
-{
-	"version": "7",
-	"dialect": "sqlite",
-	"entries": [
-		{
-			"idx": 0,
-			"version": "6",
-			"when": 1765219627085,
-			"tag": "0000_minor_iron_fist",
-			"breakpoints": true
-		}
-	]
-}

package/example_usage.ts

@@ -1,39 +0,0 @@
-// example_usage.ts
-import { EnlightenedProvider } from "./src/llm/EnlightenedProvider";
-
-async function main() {
-	// 1. Initialize the Accountant
-	const hume = new EnlightenedProvider({ port: 8083 });
-
-	// 2. Check Pulse
-	if (!(await hume.isOnline())) {
-		console.error(
-			"⚠️  The Enlightenment Server is offline. Run the Golden Command.",
-		);
-		return;
-	}
-
-	console.log("🟢 Enlightenment Engine Online.\n");
-
-	// 3. Scenario A: The Logic Check
-	console.log("--- TEST A: LOGIC ---");
-	const logicResponse = await hume.think([
-		{ role: "system", content: "You are a skeptical logician." },
-		{
-			role: "user",
-			content:
-				"I walked under a ladder and then tripped. Did the ladder cause me to trip?",
-		},
-	]);
-	console.log(`Result: ${logicResponse}\n`);
-
-	// 4. Scenario B: The "De-Fluff" Tool
-	console.log("--- TEST B: DE-FLUFFING ---");
-	const corporateJargon =
-		"We need to leverage our core competencies to shift the paradigm and boil the ocean.";
-	const cleanText = await hume.defluff(corporateJargon);
-	console.log(`Original: "${corporateJargon}"`);
-	console.log(`Cleaned:  "${cleanText}"`);
-}
-
-main();

package/experiment.sh

@@ -1,35 +0,0 @@
-#!/bin/bash
-
-# 1. Create the Hazard Lab
-mkdir -p experiments/enlightenment
-cd experiments/enlightenment
-
-# 2. Update .gitignore (Crucial: Don't commit 10GB of AI)
-# We append to the root .gitignore if these rules aren't there
-if ! grep -q "experiments/enlightenment/models" ../../.gitignore; then
-    echo -e "\n# Enlightenment Experiment\nexperiments/enlightenment/models/\nexperiments/enlightenment/venv/\nexperiments/enlightenment/__pycache__/\n*.gguf" >> ../../.gitignore
-    echo "✅ Added safety rules to .gitignore"
-fi
-
-# 3. Create Python Virtual Environment
-echo "🐍 Setting up Python environment..."
-python3 -m venv venv
-source venv/bin/activate
-
-# 4. Install Dependencies
-# repeng: The control vector library
-# torch/transformers: For calculating the vector
-echo "⬇️ Installing PyTorch and Transformers (this may take a minute)..."
-pip install torch transformers repeng tqdm notebook
-
-# 5. Clone llama.cpp (for the server)
-if [ ! -d "llama.cpp" ]; then
-    echo "🏗️ Cloning and building llama.cpp..."
-    git clone https://github.com/ggerganov/llama.cpp
-    cd llama.cpp
-    make -j4  # Build the server
-    cd ..
-fi
-
-echo "✅ Environment Ready in experiments/enlightenment/"
-echo "   Next Step: Download the Llama-3 Model."

package/hello

@@ -1,2 +0,0 @@
-
ls -la ~/.claude-code-router* 2>/dev/null || echo "No config found"
-