@geoql/mdr 0.0.1

package/dist/src/daemon.js

@@ -0,0 +1,582 @@
+import { getEntitiesDir, getIndexDir, getJournalDir, getRemindersDir, getStateRoot } from "./config.js";
+import { appendFileSync, existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync, writeFileSync } from "fs";
+import { basename, join } from "path";
+import { execSync, spawn } from "child_process";
+import { watch } from "chokidar";
+import { Cron } from "croner";
+
+//#region src/daemon.ts
+/**
+* Macrodata Local Daemon (core logic)
+*
+* Handles scheduled tasks, file watching for index updates, and triggers
+* Claude Code or OpenCode via CLI when reminders fire.
+*
+* The `bin/macrodata-daemon.ts` entry is a thin wrapper around `runDaemon()`;
+* all logic lives here so it can be imported and unit-tested directly instead
+* of only through a spawned child process.
+*
+* Environment:
+*   MACRODATA_AGENT=opencode|claude  (default: auto-detect)
+*   MACRODATA_ROOT=/path/to/state
+*   MACRODATA_CHILD_TIMEOUT_MS=<ms>  (default: 10 minutes)
+*/
+async function loadIndexer() {
+	return import("./indexer.js");
+}
+async function loadConversationIndexers() {
+	const [oc, cc] = await Promise.all([import("../opencode/conversations.js"), import("./conversations.js")]);
+	return {
+		updateOpenCodeConversations: oc.updateConversationIndex,
+		updateClaudeCodeConversations: cc.updateConversationIndex
+	};
+}
+/**
+* Find an executable in PATH
+*/
+async function findExecutable(name) {
+	try {
+		const result = execSync(`which ${name}`, { encoding: "utf-8" }).trim();
+		return result || null;
+	} catch {
+		return null;
+	}
+}
+function getDaemonDir() {
+	return getStateRoot();
+}
+function getPidFile() {
+	return join(getDaemonDir(), ".daemon.pid");
+}
+function getLogFile() {
+	return join(getDaemonDir(), ".daemon.log");
+}
+function getPendingContext() {
+	return join(getStateRoot(), ".pending-context");
+}
+function getHeartbeatFile() {
+	return join(getDaemonDir(), ".daemon.heartbeat");
+}
+const HEARTBEAT_INTERVAL_MS = 6e4;
+/**
+* Resolve the per-child hard timeout from the environment. Re-read each call so
+* tests can flip MACRODATA_CHILD_TIMEOUT_MS without reloading the module.
+*/
+function getChildTimeoutMs() {
+	const raw = process.env.MACRODATA_CHILD_TIMEOUT_MS;
+	const parsed = raw ? parseInt(raw, 10) : NaN;
+	return Number.isFinite(parsed) && parsed > 0 ? parsed : 10 * 6e4;
+}
+function log(message) {
+	const ts = new Date().toISOString();
+	const line = `[${ts}] ${message}\n`;
+	appendFileSync(getLogFile(), line);
+}
+function logError(message) {
+	const ts = new Date().toISOString();
+	const line = `[${ts}] ERROR: ${message}\n`;
+	appendFileSync(getLogFile(), line);
+}
+function writePendingContext(message) {
+	try {
+		appendFileSync(getPendingContext(), message + "\n");
+	} catch (err) {
+		logError(`Failed to write pending context: ${String(err)}`);
+	}
+}
+/**
+* Trigger an agent with a message
+*/
+async function triggerAgent(agent, message, options = {}) {
+	if (!agent) {
+		log("No agent specified in schedule, skipping trigger");
+		return false;
+	}
+	const timestamp = new Date().toLocaleString();
+	const fullMessage = `[Scheduled reminder: ${options.description || "reminder"}]
+Current time: ${timestamp}
+
+IMPORTANT: Use the macrodata_* tools (e.g., macrodata_log_journal, macrodata_search_memory) for memory operations. You are running in a non-interactive scheduled context.
+
+${message}`;
+	try {
+		if (agent === "opencode") {
+			const args = ["run", fullMessage];
+			if (options.model) {
+				args.push("--model", options.model);
+			}
+			const opencodePath = await findExecutable("opencode") || "npx";
+			const finalArgs = opencodePath === "npx" ? ["opencode", ...args] : args;
+			log(`Triggering OpenCode: ${opencodePath} ${finalArgs.join(" ").substring(0, 50)}...`);
+			spawnSupervisedChild(opencodePath, finalArgs, "opencode");
+			return true;
+		} else {
+			const args = ["--print", fullMessage];
+			log(`Triggering Claude Code: claude --print "..."`);
+			spawnSupervisedChild("claude", args, "claude");
+			return true;
+		}
+	} catch (err) {
+		logError(`Failed to trigger ${agent}: ${String(err)}`);
+	}
+	return false;
+}
+/**
+* Spawn an agent child process with a hard timeout so a hung child can never
+* wedge the daemon's scheduling (#25). The child runs in its own process
+* group; on timeout the whole group is killed and the daemon keeps running.
+*/
+function spawnSupervisedChild(command, args, label) {
+	const childTimeoutMs = getChildTimeoutMs();
+	const proc = spawn(command, args, {
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		],
+		detached: true,
+		env: {
+			...process.env,
+			PATH: process.env.PATH
+		}
+	});
+	proc.unref();
+	const killTimer = setTimeout(() => {
+		log(`[${label}] child exceeded ${childTimeoutMs}ms timeout, killing process group ${proc.pid}`);
+		if (proc.pid) {
+			try {
+				process.kill(-proc.pid, "SIGKILL");
+			} catch {
+				try {
+					proc.kill("SIGKILL");
+				} catch {}
+			}
+		}
+	}, childTimeoutMs);
+	killTimer.unref();
+	proc.stdout?.on("data", (data) => {
+		log(`[${label} stdout] ${data.toString().trim()}`);
+	});
+	proc.stderr?.on("data", (data) => {
+		log(`[${label} stderr] ${data.toString().trim()}`);
+	});
+	proc.on("error", (err) => {
+		clearTimeout(killTimer);
+		logError(`[${label}] child process error: ${String(err)}`);
+	});
+	proc.on("exit", (code, signal) => {
+		clearTimeout(killTimer);
+		log(`[${label}] child exited (code=${code}, signal=${signal})`);
+	});
+	return proc;
+}
+function ensureDirectories() {
+	const entitiesDir = getEntitiesDir();
+	const dirs = [
+		getDaemonDir(),
+		getStateRoot(),
+		getIndexDir(),
+		entitiesDir,
+		getJournalDir(),
+		getRemindersDir(),
+		join(entitiesDir, "people"),
+		join(entitiesDir, "projects")
+	];
+	for (const dir of dirs) {
+		if (!existsSync(dir)) {
+			mkdirSync(dir, { recursive: true });
+			log(`Created directory: ${dir}`);
+		}
+	}
+}
+async function updateAllConversationIndexes(loaders = loadConversationIndexers) {
+	const { updateClaudeCodeConversations, updateOpenCodeConversations } = await loaders();
+	try {
+		const claude = await updateClaudeCodeConversations();
+		if (claude.filesUpdated > 0) {
+			log(`Claude Code conversations: +${claude.filesUpdated} files (${claude.exchangeCount} total)`);
+		}
+	} catch (err) {
+		logError(`Claude Code conversation index failed: ${String(err)}`);
+	}
+	try {
+		const opencode = await updateOpenCodeConversations();
+		if (opencode.newCount > 0) {
+			log(`OpenCode conversations: +${opencode.newCount} (${opencode.totalCount} total)`);
+		}
+	} catch (err) {
+		logError(`OpenCode conversation index failed: ${String(err)}`);
+	}
+}
+function loadAllSchedules() {
+	const remindersDir = getRemindersDir();
+	const schedules = [];
+	try {
+		if (!existsSync(remindersDir)) return schedules;
+		const files = readdirSync(remindersDir).filter((f) => f.endsWith(".json"));
+		for (const file of files) {
+			try {
+				const content = readFileSync(join(remindersDir, file), "utf-8");
+				const schedule = JSON.parse(content);
+				schedules.push(schedule);
+			} catch (err) {
+				logError(`Failed to load schedule ${file}: ${String(err)}`);
+			}
+		}
+	} catch (err) {
+		logError(`Failed to read reminders directory: ${String(err)}`);
+	}
+	return schedules;
+}
+function saveSchedule(schedule) {
+	const remindersDir = getRemindersDir();
+	const filePath = join(remindersDir, `${schedule.id}.json`);
+	try {
+		writeFileSync(filePath, JSON.stringify(schedule, null, 2));
+	} catch (err) {
+		logError(`Failed to save schedule ${schedule.id}: ${String(err)}`);
+	}
+}
+function deleteScheduleFile(id) {
+	const remindersDir = getRemindersDir();
+	const filePath = join(remindersDir, `${id}.json`);
+	try {
+		if (existsSync(filePath)) {
+			unlinkSync(filePath);
+		}
+	} catch (err) {
+		logError(`Failed to delete schedule file ${id}: ${String(err)}`);
+	}
+}
+async function defaultBackgroundIndexing(deps = {}) {
+	const load = deps.loadIndexer ?? loadIndexer;
+	const updateAll = deps.updateAll ?? updateAllConversationIndexes;
+	const indexer = await load();
+	await indexer.preloadModel();
+	log("Embedding model preloaded");
+	await updateAll();
+}
+var MacrodataLocalDaemon = class {
+	cronJobs = new Map();
+	watcher = null;
+	schedulesWatcher = null;
+	heartbeatTimer = null;
+	shouldRun = true;
+	backgroundIndexing;
+	indexerLoader;
+	constructor(options = {}) {
+		this.backgroundIndexing = options.backgroundIndexing ?? defaultBackgroundIndexing;
+		this.indexerLoader = options.indexerLoader ?? loadIndexer;
+	}
+	async start() {
+		log("Starting macrodata local daemon");
+		log(`State root: ${getStateRoot()}`);
+		ensureDirectories();
+		const pidFile = getPidFile();
+		if (existsSync(pidFile)) {
+			const existingPid = readFileSync(pidFile, "utf-8").trim();
+			try {
+				process.kill(parseInt(existingPid, 10), 0);
+				log(`Daemon already running (PID ${existingPid}), exiting`);
+				process.exit(0);
+			} catch {
+				log(`Removing stale PID file (was ${existingPid})`);
+			}
+		}
+		writeFileSync(pidFile, process.pid.toString());
+		process.on("SIGTERM", () => this.shutdown("SIGTERM"));
+		process.on("SIGINT", () => this.shutdown("SIGINT"));
+		process.on("SIGHUP", () => this.reload());
+		process.on("unhandledRejection", (reason) => {
+			logError(`Unhandled rejection (daemon continues): ${String(reason)}`);
+		});
+		process.on("uncaughtException", (err) => {
+			logError(`Uncaught exception (daemon continues): ${String(err?.stack || err)}`);
+		});
+		this.backgroundIndexing().catch((err) => logError(`Failed to preload/index: ${err}`));
+		this.loadAndStartSchedules();
+		this.watchRemindersDir();
+		this.startFileWatcher();
+		this.startHeartbeat();
+		log("Daemon running");
+	}
+	startHeartbeat() {
+		const beat = () => {
+			try {
+				writeFileSync(getHeartbeatFile(), Date.now().toString());
+			} catch (err) {
+				logError(`Heartbeat write failed: ${String(err)}`);
+			}
+		};
+		beat();
+		this.heartbeatTimer = setInterval(beat, HEARTBEAT_INTERVAL_MS);
+	}
+	watchRemindersDir() {
+		const remindersDir = getRemindersDir();
+		log(`Watching for reminders in: ${remindersDir}`);
+		this.schedulesWatcher = watch(remindersDir, {
+			ignoreInitial: true,
+			awaitWriteFinish: { stabilityThreshold: 100 }
+		});
+		this.schedulesWatcher.on("add", (path) => {
+			if (!path.endsWith(".json")) return;
+			log(`Reminder added: ${basename(path)}`);
+			this.reloadSchedules();
+			try {
+				const schedule = JSON.parse(readFileSync(path, "utf-8"));
+				writePendingContext(`<macrodata-update type="schedule-added" id="${schedule.id}">${schedule.description}</macrodata-update>`);
+			} catch {}
+		});
+		this.schedulesWatcher.on("error", (err) => {
+			logError(`Reminders watcher error: ${String(err)}`);
+		});
+		this.schedulesWatcher.on("change", (path) => {
+			if (!path.endsWith(".json")) return;
+			log(`Reminder changed: ${basename(path)}`);
+			this.reloadSchedules();
+			try {
+				const schedule = JSON.parse(readFileSync(path, "utf-8"));
+				writePendingContext(`<macrodata-update type="schedule-updated" id="${schedule.id}">${schedule.description}</macrodata-update>`);
+			} catch {}
+		});
+		this.schedulesWatcher.on("unlink", (path) => this.onReminderUnlinked(path));
+	}
+	onReminderUnlinked(path) {
+		if (!path.endsWith(".json")) return;
+		const id = basename(path, ".json");
+		log(`Reminder removed: ${id}`);
+		writePendingContext(`<macrodata-update type="schedule-removed" id="${id}" />`);
+		if (this.cronJobs.has(id)) {
+			this.stopJob(id);
+			log(`Stopped job: ${id}`);
+		}
+	}
+	scheduleFor(schedule) {
+		if (schedule.type === "cron") {
+			this.startCronJob(schedule);
+			return;
+		}
+		if (schedule.type === "once") {
+			if (new Date(schedule.expression).getTime() > Date.now()) {
+				this.startOnceJob(schedule);
+			} else {
+				log(`Skipping expired one-shot: ${schedule.id}`);
+				this.removeSchedule(schedule.id);
+			}
+		}
+	}
+	stopJob(id) {
+		const job = this.cronJobs.get(id);
+		if (job) {
+			job.stop();
+			this.cronJobs.delete(id);
+		}
+	}
+	reloadSchedules() {
+		const schedules = loadAllSchedules();
+		const currentIds = new Set(this.cronJobs.keys());
+		for (const schedule of schedules) {
+			if (currentIds.has(schedule.id)) {
+				currentIds.delete(schedule.id);
+				continue;
+			}
+			this.scheduleFor(schedule);
+		}
+		for (const id of currentIds) {
+			this.stopJob(id);
+			log(`Stopped removed job: ${id}`);
+		}
+	}
+	loadAndStartSchedules() {
+		for (const schedule of loadAllSchedules()) {
+			this.scheduleFor(schedule);
+		}
+	}
+	startCronJob(schedule) {
+		try {
+			const job = new Cron(schedule.expression, () => {
+				void this.fireSchedule(schedule);
+			});
+			this.cronJobs.set(schedule.id, job);
+			log(`Started cron job: ${schedule.id} (${schedule.expression})`);
+		} catch (err) {
+			logError(`Failed to start cron job ${schedule.id}: ${String(err)}`);
+		}
+	}
+	startOnceJob(schedule) {
+		try {
+			const fireTime = new Date(schedule.expression);
+			const job = new Cron(fireTime, () => {
+				void this.fireSchedule(schedule);
+				this.removeSchedule(schedule.id);
+			});
+			this.cronJobs.set(schedule.id, job);
+			log(`Scheduled one-shot: ${schedule.id} at ${schedule.expression}`);
+		} catch (err) {
+			log(`Failed to schedule one-shot ${schedule.id}: ${String(err)}`);
+		}
+	}
+	async fireSchedule(schedule) {
+		log(`Firing schedule: ${schedule.id} - ${schedule.description}`);
+		const triggered = await triggerAgent(schedule.agent, schedule.payload, {
+			model: schedule.model,
+			description: schedule.description
+		});
+		if (triggered) {
+			log(`Successfully triggered ${schedule.agent} for: ${schedule.id}`);
+		} else if (schedule.agent) {
+			log(`Failed to trigger ${schedule.agent} for: ${schedule.id}`);
+		} else {
+			log(`No agent specified for: ${schedule.id} (pending context written)`);
+		}
+	}
+	addSchedule(schedule) {
+		saveSchedule(schedule);
+		if (schedule.type === "cron") {
+			this.startCronJob(schedule);
+		} else {
+			this.startOnceJob(schedule);
+		}
+	}
+	removeSchedule(id) {
+		this.stopJob(id);
+		deleteScheduleFile(id);
+		log(`Removed schedule: ${id}`);
+	}
+	startFileWatcher() {
+		const stateRoot = getStateRoot();
+		const entitiesDir = getEntitiesDir();
+		const stateDir = join(stateRoot, "state");
+		this.watcher = watch([stateDir, entitiesDir], {
+			ignoreInitial: true,
+			persistent: true
+		});
+		this.watcher.on("all", (event, path) => this.onWatchedFileEvent(event, path));
+		log(`Watching for state/entity changes in: ${stateRoot}`);
+	}
+	onWatchedFileEvent(event, path) {
+		if (!path.endsWith(".md")) return;
+		if (event !== "add" && event !== "change") return;
+		log(`File ${event}: ${path}`);
+		const stateDir = join(getStateRoot(), "state");
+		const entitiesDir = getEntitiesDir();
+		if (path.startsWith(stateDir)) {
+			this.injectStateFileDelta(path);
+		} else if (path.startsWith(entitiesDir)) {
+			const relative = path.slice(entitiesDir.length + 1);
+			writePendingContext(`<macrodata-update type="entity" file="${relative}" />`);
+			this.queueReindex(path);
+		}
+	}
+	injectStateFileDelta(path) {
+		try {
+			const raw = readFileSync(path, "utf-8");
+			const cap = 4e3;
+			const content = raw.length > cap ? `${raw.slice(0, cap)}\n[…truncated: ${cap} of ${raw.length} chars. This file is over budget — compact it.]` : raw;
+			writePendingContext(`<macrodata-update type="state" file="${basename(path)}">\n${content}\n</macrodata-update>`);
+		} catch {}
+	}
+	reindexQueue = new Set();
+	reindexTimer = null;
+	queueReindex(path) {
+		this.reindexQueue.add(path);
+		if (this.reindexTimer) {
+			clearTimeout(this.reindexTimer);
+		}
+		this.reindexTimer = setTimeout(() => {
+			void this.processReindexQueue();
+		}, 1e3);
+	}
+	async processReindexQueue() {
+		if (this.reindexQueue.size === 0) return;
+		const paths = Array.from(this.reindexQueue);
+		this.reindexQueue.clear();
+		log(`Reindexing ${paths.length} file(s)`);
+		const indexer = await this.indexerLoader();
+		for (const path of paths) {
+			try {
+				await indexer.indexEntityFile(path);
+				log(`  ✓ ${basename(path)}`);
+			} catch (err) {
+				log(`  ✗ ${basename(path)}: ${String(err)}`);
+			}
+		}
+	}
+	reload() {
+		log("Reloading config (SIGHUP)");
+		log(`New state root: ${getStateRoot()}`);
+		if (this.watcher) {
+			void this.watcher.close();
+			this.watcher = null;
+		}
+		if (this.schedulesWatcher) {
+			void this.schedulesWatcher.close();
+			this.schedulesWatcher = null;
+		}
+		for (const [, job] of this.cronJobs) {
+			job.stop();
+		}
+		this.cronJobs.clear();
+		ensureDirectories();
+		this.loadAndStartSchedules();
+		this.watchRemindersDir();
+		this.startFileWatcher();
+		log("Reload complete");
+	}
+	shutdown(signal) {
+		log(`Shutting down (${signal})`);
+		this.shouldRun = false;
+		if (this.heartbeatTimer) {
+			clearInterval(this.heartbeatTimer);
+			this.heartbeatTimer = null;
+		}
+		for (const [, job] of this.cronJobs) {
+			job.stop();
+		}
+		this.cronJobs.clear();
+		if (this.watcher) {
+			void this.watcher.close();
+			this.watcher = null;
+		}
+		if (this.schedulesWatcher) {
+			void this.schedulesWatcher.close();
+			this.schedulesWatcher = null;
+		}
+		try {
+			const pidFile = getPidFile();
+			if (existsSync(pidFile)) {
+				const pid = readFileSync(pidFile, "utf-8").trim();
+				if (pid === process.pid.toString()) {
+					unlinkSync(pidFile);
+				}
+			}
+		} catch {}
+		process.exit(0);
+	}
+	/** Test-only accessor: whether the daemon considers itself running. */
+	get running() {
+		return this.shouldRun;
+	}
+	/** Test-only accessor: number of active cron jobs. */
+	get jobCount() {
+		return this.cronJobs.size;
+	}
+	/** Test-only accessor: the reminders-directory watcher, for error injection. */
+	get remindersWatcher() {
+		return this.schedulesWatcher;
+	}
+};
+/**
+* Entrypoint used by bin/macrodata-daemon.ts.
+*/
+function runDaemon() {
+	const daemon = new MacrodataLocalDaemon();
+	daemon.start().catch((err) => {
+		log(`Fatal error: ${err}`);
+		process.exit(1);
+	});
+	return daemon;
+}
+
+//#endregion
+export { HEARTBEAT_INTERVAL_MS, MacrodataLocalDaemon, defaultBackgroundIndexing, deleteScheduleFile, ensureDirectories, findExecutable, getChildTimeoutMs, getDaemonDir, getHeartbeatFile, getLogFile, getPendingContext, getPidFile, loadAllSchedules, loadConversationIndexers, loadIndexer, log, logError, runDaemon, saveSchedule, spawnSupervisedChild, triggerAgent, updateAllConversationIndexes, writePendingContext };

package/dist/src/detect-user.js

@@ -0,0 +1,73 @@
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { execSync } from "child_process";
+
+//#region src/detect-user.ts
+/**
+* Detect user information for onboarding
+* Returns JSON with system, git, github, and code directory info
+*/
+function exec(cmd) {
+	try {
+		return execSync(cmd, {
+			encoding: "utf-8",
+			stdio: [
+				"pipe",
+				"pipe",
+				"pipe"
+			]
+		}).trim();
+	} catch {
+		return "";
+	}
+}
+function detectUser() {
+	const username = exec("whoami");
+	const fullName = exec("id -F") || exec(`getent passwd ${username} | cut -d: -f5 | cut -d, -f1`);
+	let timezone = "";
+	if (existsSync("/etc/timezone")) {
+		timezone = exec("cat /etc/timezone");
+	} else if (existsSync("/etc/localtime")) {
+		timezone = exec("readlink /etc/localtime | sed 's|.*/zoneinfo/||'");
+	}
+	const gitName = exec("git config --global user.name");
+	const gitEmail = exec("git config --global user.email");
+	let github = {};
+	const ghCheck = exec("command -v gh");
+	if (ghCheck) {
+		const ghJson = exec("gh api user --jq '{login: .login, name: .name, blog: .blog, bio: .bio}'");
+		if (ghJson) {
+			try {
+				github = JSON.parse(ghJson);
+			} catch {}
+		}
+	}
+	const home = homedir();
+	const possibleDirs = [
+		"Repos",
+		"repos",
+		"Code",
+		"code",
+		"Projects",
+		"projects",
+		"Developer",
+		"dev",
+		"src"
+	];
+	const codeDirs = possibleDirs.map((dir) => join(home, dir)).filter((dir) => existsSync(dir));
+	return {
+		username,
+		fullName,
+		timezone,
+		git: {
+			name: gitName,
+			email: gitEmail
+		},
+		github,
+		codeDirs
+	};
+}
+
+//#endregion
+export { detectUser };