@noxsoft/anima 2.0.0

package/dist/engine-ZSd5I5JN.js

@@ -0,0 +1,561 @@
+import { n as loadIdentity } from "./loader-Dmc0KyQK.js";
+import { SessionOrchestrator } from "./orchestrator-CYTk7mq6.js";
+import { execFile } from "node:child_process";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { existsSync } from "node:fs";
+import { promisify } from "node:util";
+import { mkdir, writeFile } from "node:fs/promises";
+import { EventEmitter } from "node:events";
+
+//#region src/heartbeat/self-replication.ts
+/**
+* Self-Replication — ensures ANIMA survives restarts and system reboots.
+*
+* On macOS: uses launchd to register a persistent agent.
+* Fallback: uses nohup to schedule manual restart.
+*
+* Security: all subprocess calls use execFile (not exec).
+*/
+const execFile$1 = promisify(execFile);
+const PLIST_LABEL = "net.noxsoft.anima";
+const PLIST_DIR = join(homedir(), "Library", "LaunchAgents");
+const PLIST_PATH = join(PLIST_DIR, `${PLIST_LABEL}.plist`);
+const ANIMA_DIR = join(homedir(), ".anima");
+/**
+* Generate the launchd plist XML for ANIMA.
+*
+* KeepAlive ensures launchd restarts ANIMA if it crashes.
+* StartInterval provides the heartbeat timing at the OS level.
+*/
+function generatePlist() {
+	return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>Label</key>
+    <string>${PLIST_LABEL}</string>
+
+    <key>ProgramArguments</key>
+    <array>
+        <string>${process.argv[1] || join(ANIMA_DIR, "bin", "anima")}</string>
+        <string>heartbeat</string>
+        <string>--daemon</string>
+    </array>
+
+    <key>KeepAlive</key>
+    <true/>
+
+    <key>RunAtLoad</key>
+    <true/>
+
+    <key>StartInterval</key>
+    <integer>300</integer>
+
+    <key>StandardOutPath</key>
+    <string>${join(ANIMA_DIR, "logs", "anima-stdout.log")}</string>
+
+    <key>StandardErrorPath</key>
+    <string>${join(ANIMA_DIR, "logs", "anima-stderr.log")}</string>
+
+    <key>WorkingDirectory</key>
+    <string>${homedir()}</string>
+
+    <key>EnvironmentVariables</key>
+    <dict>
+        <key>HOME</key>
+        <string>${homedir()}</string>
+        <key>PATH</key>
+        <string>/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin</string>
+    </dict>
+
+    <key>ProcessType</key>
+    <string>Background</string>
+
+    <key>LowPriorityIO</key>
+    <true/>
+</dict>
+</plist>`;
+}
+/**
+* Check if the launchd agent is currently loaded.
+*/
+async function isLaunchdLoaded() {
+	try {
+		const { stdout } = await execFile$1("launchctl", ["list"]);
+		return stdout.includes(PLIST_LABEL);
+	} catch {
+		return false;
+	}
+}
+/**
+* Register the launchd agent.
+*/
+async function registerLaunchd() {
+	await mkdir(PLIST_DIR, { recursive: true });
+	await mkdir(join(ANIMA_DIR, "logs"), { recursive: true });
+	await writeFile(PLIST_PATH, generatePlist(), "utf-8");
+	try {
+		await execFile$1("launchctl", ["unload", PLIST_PATH]);
+	} catch {}
+	await execFile$1("launchctl", ["load", PLIST_PATH]);
+}
+/**
+* Schedule a manual fallback restart using nohup.
+* This is used if launchd registration fails.
+*/
+async function scheduleFallback() {
+	const animaBin = process.argv[1] || join(ANIMA_DIR, "bin", "anima");
+	const logFile = join(ANIMA_DIR, "logs", "fallback.log");
+	await mkdir(join(ANIMA_DIR, "logs"), { recursive: true });
+	const restartScript = join(ANIMA_DIR, "restart.sh");
+	await writeFile(restartScript, `#!/bin/bash
+# ANIMA fallback restart script
+sleep 10
+nohup "${animaBin}" heartbeat --daemon >> "${logFile}" 2>&1 &
+echo "ANIMA restarted at $(date)" >> "${logFile}"
+`, { mode: 493 });
+	try {
+		await execFile$1("bash", [restartScript]);
+	} catch {
+		await writeFile(logFile, `[${(/* @__PURE__ */ new Date()).toISOString()}] Failed to schedule fallback restart\n`, { flag: "a" });
+	}
+}
+/**
+* Ensure ANIMA's continuity — called at the start of every heartbeat.
+*
+* Checks if launchd agent is registered and running.
+* Re-registers if missing. Falls back to nohup if launchd fails.
+*/
+async function ensureContinuity() {
+	const status = {
+		launchdRegistered: false,
+		plistExists: false,
+		fallbackScheduled: false,
+		checkedAt: /* @__PURE__ */ new Date()
+	};
+	status.plistExists = existsSync(PLIST_PATH);
+	status.launchdRegistered = await isLaunchdLoaded();
+	if (status.launchdRegistered) return status;
+	try {
+		await registerLaunchd();
+		status.launchdRegistered = await isLaunchdLoaded();
+		status.plistExists = existsSync(PLIST_PATH);
+	} catch {
+		try {
+			await scheduleFallback();
+			status.fallbackScheduled = true;
+		} catch {}
+	}
+	return status;
+}
+
+//#endregion
+//#region src/heartbeat/cycle.ts
+/**
+* Heartbeat Cycle — the actual work performed in each beat.
+*
+* Each cycle runs through a sequence of steps:
+* 1. Self-check (continuity)
+* 2. Identity load
+* 3. Comms check
+* 4. Task check
+* 5. Platform audit
+* 6. MCP health check
+* 7. Dispatch work
+* 8. Memory consolidation
+* 9. Freedom time
+* 10. Status report
+*/
+/**
+* Run a single step with timing and error handling.
+*/
+async function runStep(name, fn) {
+	const start = Date.now();
+	try {
+		const output = await fn();
+		return {
+			name,
+			status: "completed",
+			durationMs: Date.now() - start,
+			output: output || void 0
+		};
+	} catch (err) {
+		const error = err instanceof Error ? err.message : String(err);
+		return {
+			name,
+			status: "failed",
+			durationMs: Date.now() - start,
+			error
+		};
+	}
+}
+const stepSelfCheck = async (_beatNumber, _orchestrator, options) => {
+	if (!options.selfReplication) return {
+		name: "self-check",
+		status: "skipped",
+		durationMs: 0
+	};
+	return runStep("self-check", async () => {
+		await ensureContinuity();
+		return "Continuity ensured";
+	});
+};
+const stepIdentityLoad = async () => {
+	return runStep("identity-load", async () => {
+		const identity = await loadIdentity();
+		return `Identity loaded (${Object.values(identity.loadedFrom).filter((s) => s === "user").length}/7 user-customized)`;
+	});
+};
+const stepCommsCheck = async (beatNumber, orchestrator) => {
+	return runStep("comms-check", async () => {
+		return (await orchestrator.executeTask({
+			taskDescription: "Check NoxSoft communications: read recent messages from #hello and #nox-primary channels, check email inbox. Report any unread messages or action items. Be brief.",
+			maxBudgetUsd: 2,
+			timeoutMs: 12e4,
+			dangerouslySkipPermissions: true
+		})).output;
+	});
+};
+const stepTaskCheck = async (_beatNumber, orchestrator) => {
+	return runStep("task-check", async () => {
+		return (await orchestrator.executeTask({
+			taskDescription: "Check the active task list. List any pending, in-progress, or blocked tasks. Prioritize by urgency. Be brief.",
+			maxBudgetUsd: 1,
+			timeoutMs: 6e4,
+			dangerouslySkipPermissions: true
+		})).output;
+	});
+};
+const stepPlatformAudit = async (beatNumber, orchestrator) => {
+	const tiers = [
+		[
+			"auth.noxsoft.net",
+			"nox.noxsoft.net",
+			"mail.noxsoft.net"
+		],
+		[
+			"bynd.noxsoft.net",
+			"chat.noxsoft.net",
+			"veritas.noxsoft.net"
+		],
+		[
+			"heal.noxsoft.net",
+			"veil.noxsoft.net",
+			"agents.noxsoft.net"
+		]
+	];
+	const currentTier = tiers[beatNumber % tiers.length];
+	return runStep("platform-audit", async () => {
+		return (await orchestrator.executeTask({
+			taskDescription: `Audit these NoxSoft platforms: ${currentTier.join(", ")}. Check if they load, test basic functionality, report any issues. Be brief.`,
+			maxBudgetUsd: 3,
+			timeoutMs: 18e4,
+			dangerouslySkipPermissions: true
+		})).output;
+	});
+};
+const stepMCPHealthCheck = async (_beatNumber, orchestrator) => {
+	return runStep("mcp-health", async () => {
+		return (await orchestrator.executeTask({
+			taskDescription: "Check MCP server health. Verify NoxSoft MCP and any other configured servers are responsive. Be brief.",
+			maxBudgetUsd: 1,
+			timeoutMs: 6e4,
+			dangerouslySkipPermissions: true
+		})).output;
+	});
+};
+const stepDispatchWork = async (_beatNumber, orchestrator) => {
+	return runStep("dispatch-work", async () => {
+		return (await orchestrator.executeTask({
+			taskDescription: "Review pending tasks. If there are high-priority tasks that can be started now, begin work on the most important one. If no urgent tasks, report \"No urgent work to dispatch.\" Be brief.",
+			maxBudgetUsd: 5,
+			timeoutMs: 3e5,
+			dangerouslySkipPermissions: true
+		})).output;
+	});
+};
+const stepMemoryConsolidation = async (_beatNumber, orchestrator) => {
+	if ((/* @__PURE__ */ new Date()).getHours() < 22) return {
+		name: "memory-consolidation",
+		status: "skipped",
+		durationMs: 0
+	};
+	return runStep("memory-consolidation", async () => {
+		return (await orchestrator.executeTask({
+			taskDescription: "Consolidate today's memory. Review session transcripts from today, extract key learnings, compress older episodes into semantic knowledge. Be brief.",
+			maxBudgetUsd: 2,
+			timeoutMs: 12e4,
+			dangerouslySkipPermissions: true
+		})).output;
+	});
+};
+const stepFreedomTime = async (_beatNumber, orchestrator, options) => {
+	if (!options.freedomTime) return {
+		name: "freedom-time",
+		status: "skipped",
+		durationMs: 0
+	};
+	return runStep("freedom-time", async () => {
+		return (await orchestrator.executeFreedom({
+			maxBudgetUsd: 5,
+			timeoutMs: 6e5
+		})).output;
+	});
+};
+const stepStatusReport = async (beatNumber, orchestrator) => {
+	return runStep("status-report", async () => {
+		return (await orchestrator.executeTask({
+			taskDescription: `Post a brief status update to #hello channel. Sign as "ANIMA (heartbeat #${beatNumber})". Include: what you checked, any issues found, what you dispatched. Keep it under 5 lines.`,
+			maxBudgetUsd: 1,
+			timeoutMs: 6e4,
+			dangerouslySkipPermissions: true
+		})).output;
+	});
+};
+/**
+* Execute a full heartbeat cycle.
+*/
+async function executeCycle(beatNumber, orchestrator, options) {
+	const startedAt = /* @__PURE__ */ new Date();
+	const steps = [];
+	const errors = [];
+	const allSteps = [
+		stepSelfCheck,
+		stepIdentityLoad,
+		stepCommsCheck,
+		stepTaskCheck,
+		stepPlatformAudit,
+		stepMCPHealthCheck,
+		stepDispatchWork,
+		stepMemoryConsolidation,
+		stepFreedomTime,
+		stepStatusReport
+	];
+	for (const stepFn of allSteps) {
+		const result = await stepFn(beatNumber, orchestrator, options);
+		steps.push(result);
+		if (result.status === "failed" && result.error) errors.push(`${result.name}: ${result.error}`);
+	}
+	return {
+		beatNumber,
+		startedAt,
+		completedAt: /* @__PURE__ */ new Date(),
+		steps,
+		freedomTime: options.freedomTime,
+		errors
+	};
+}
+
+//#endregion
+//#region src/heartbeat/adaptive.ts
+/**
+* Create a fresh metrics object.
+*/
+function createMetrics() {
+	return {
+		beatsCompleted: 0,
+		messagesReceived: 0,
+		tasksCompleted: 0,
+		errorsEncountered: 0,
+		lastBeatErrors: 0,
+		lastReset: /* @__PURE__ */ new Date()
+	};
+}
+/**
+* Check if it's currently night time (11pm - 7am).
+*/
+function isNightTime() {
+	const hour = (/* @__PURE__ */ new Date()).getHours();
+	return hour >= 23 || hour < 7;
+}
+/**
+* Calculate the activity score (higher = more active).
+*
+* Each factor contributes to the score:
+* - Recent messages: +2 per message
+* - Recent tasks completed: +3 per task
+* - Recent errors: +5 per error (errors need faster response)
+* - Last beat had errors: +10 (immediate follow-up needed)
+*/
+function calculateActivityScore(metrics) {
+	let score = 0;
+	score += metrics.messagesReceived * 2;
+	score += metrics.tasksCompleted * 3;
+	score += metrics.errorsEncountered * 5;
+	if (metrics.lastBeatErrors > 0) score += 10;
+	return score;
+}
+/**
+* Calculate the next interval based on activity metrics.
+*
+* High activity -> shorter interval (more frequent beats)
+* Low activity -> longer interval (less frequent beats)
+* Night time -> multiplied by 2x for longer intervals
+*/
+function calculateNextInterval(metrics, config) {
+	const activityScore = calculateActivityScore(metrics);
+	let intervalMs;
+	if (activityScore === 0) intervalMs = config.maxMs;
+	else if (activityScore <= 5) intervalMs = config.defaultMs * 1.5;
+	else if (activityScore <= 15) intervalMs = config.defaultMs;
+	else if (activityScore <= 30) intervalMs = config.defaultMs * .5;
+	else intervalMs = config.minMs;
+	if (isNightTime()) intervalMs *= 2;
+	intervalMs = Math.max(config.minMs, Math.min(config.maxMs, intervalMs));
+	return Math.round(intervalMs);
+}
+
+//#endregion
+//#region src/heartbeat/engine.ts
+/**
+* Heartbeat Engine — the main life process controller.
+*
+* Manages start/stop/pause/resume of the heartbeat cycle,
+* with adaptive interval adjustment and event emission.
+*/
+const DEFAULT_CONFIG = {
+	intervalMs: 3e5,
+	minIntervalMs: 6e4,
+	maxIntervalMs: 18e5,
+	adaptive: true,
+	selfReplication: true,
+	freedomEveryN: 3
+};
+var HeartbeatEngine = class extends EventEmitter {
+	constructor(orchestrator, config) {
+		super();
+		this.timer = null;
+		this.beatCount = 0;
+		this.lastBeatTime = null;
+		this.nextBeatTime = null;
+		this.running = false;
+		this.paused = false;
+		this.config = {
+			...DEFAULT_CONFIG,
+			...config
+		};
+		this.orchestrator = orchestrator || new SessionOrchestrator();
+		this.currentIntervalMs = this.config.intervalMs;
+		this.metrics = createMetrics();
+	}
+	/**
+	* Start the heartbeat engine.
+	* Runs the first beat immediately, then schedules subsequent beats.
+	*/
+	async start() {
+		if (this.running) return;
+		this.running = true;
+		this.paused = false;
+		if (this.config.selfReplication) await ensureContinuity();
+		await this.executeBeat();
+		this.scheduleNextBeat();
+	}
+	/**
+	* Stop the heartbeat engine.
+	*/
+	stop() {
+		this.running = false;
+		this.paused = false;
+		if (this.timer) {
+			clearTimeout(this.timer);
+			this.timer = null;
+		}
+		this.nextBeatTime = null;
+		this.emit("stopped");
+	}
+	/**
+	* Pause the heartbeat engine (keeps state, stops scheduling).
+	*/
+	pause() {
+		if (!this.running || this.paused) return;
+		this.paused = true;
+		if (this.timer) {
+			clearTimeout(this.timer);
+			this.timer = null;
+		}
+		this.nextBeatTime = null;
+		this.emit("paused");
+	}
+	/**
+	* Resume after a pause.
+	*/
+	resume() {
+		if (!this.running || !this.paused) return;
+		this.paused = false;
+		this.scheduleNextBeat();
+		this.emit("resumed");
+	}
+	/**
+	* Execute a single heartbeat cycle.
+	*/
+	async executeBeat() {
+		this.beatCount++;
+		const beatNumber = this.beatCount;
+		this.lastBeatTime = /* @__PURE__ */ new Date();
+		this.emit("beat-start", {
+			beatNumber,
+			startedAt: this.lastBeatTime
+		});
+		try {
+			const result = await executeCycle(beatNumber, this.orchestrator, {
+				selfReplication: this.config.selfReplication,
+				freedomTime: beatNumber % this.config.freedomEveryN === 0
+			});
+			this.emit("beat-complete", result);
+			if (result.freedomTime) this.emit("freedom-time", { beatNumber });
+			this.metrics.beatsCompleted++;
+			this.metrics.lastBeatErrors = result.errors.length;
+			if (result.errors.length > 0) this.metrics.errorsEncountered += result.errors.length;
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			this.emit("beat-error", {
+				beatNumber,
+				error: message
+			});
+			this.metrics.errorsEncountered++;
+		}
+		if (this.config.adaptive) this.currentIntervalMs = calculateNextInterval(this.metrics, {
+			minMs: this.config.minIntervalMs,
+			maxMs: this.config.maxIntervalMs,
+			defaultMs: this.config.intervalMs
+		});
+	}
+	/**
+	* Schedule the next beat based on current interval.
+	*/
+	scheduleNextBeat() {
+		if (!this.running || this.paused) return;
+		this.nextBeatTime = new Date(Date.now() + this.currentIntervalMs);
+		this.timer = setTimeout(async () => {
+			if (!this.running || this.paused) return;
+			await this.executeBeat();
+			this.scheduleNextBeat();
+		}, this.currentIntervalMs);
+		if (this.timer && typeof this.timer === "object" && "unref" in this.timer) this.timer.unref();
+	}
+	getBeatCount() {
+		return this.beatCount;
+	}
+	getLastBeatTime() {
+		return this.lastBeatTime;
+	}
+	getNextBeatTime() {
+		return this.nextBeatTime;
+	}
+	getCurrentInterval() {
+		return this.currentIntervalMs;
+	}
+	isRunning() {
+		return this.running;
+	}
+	isPaused() {
+		return this.paused;
+	}
+	getMetrics() {
+		return { ...this.metrics };
+	}
+};
+
+//#endregion
+export { HeartbeatEngine };