@geoql/mdr 0.0.1

package/dist/bin/macrodata-daemon.js

@@ -0,0 +1,30 @@
+#!/usr/bin/env node
+import { runDaemon } from "../src/daemon.js";
+
+//#region bin/macrodata-daemon.ts
+/**
+* Macrodata Local Daemon entry point.
+*
+* All logic lives in `src/daemon.ts` (importable and unit-tested). This file is
+* a thin CLI wrapper so the compiled `dist/bin/macrodata-daemon.js` stays the
+* spawn target for the plugin and hook script.
+*
+* Usage:
+*   MACRODATA_ROOT=~/.config/macrodata node macrodata-daemon.js
+*
+* Environment:
+*   MACRODATA_AGENT=opencode|claude  (default: auto-detect)
+*   MACRODATA_ROOT=/path/to/state
+*/
+function isRunAsMain(argv1, moduleUrl) {
+	return Boolean(argv1) && moduleUrl === `file://${argv1}`;
+}
+/* v8 ignore next 3 -- entry-point glue: only runs when this file is the process
+entry (node dist/bin/macrodata-daemon.js), a subprocess vitest cannot
+instrument. runDaemon() is covered directly in the daemon tests. */
+if (isRunAsMain(process.argv[1], import.meta.url)) {
+	runDaemon();
+}
+
+//#endregion
+export { isRunAsMain };

package/dist/opencode/context.js

@@ -0,0 +1,210 @@
+import { getJournalDir, getRemindersDir, getStateRoot } from "../src/config.js";
+import { detectUser } from "../src/detect-user.js";
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync } from "fs";
+import { join } from "path";
+
+//#region opencode/context.ts
+/**
+* Context formatting for OpenCode plugin
+*
+* Reads state files and formats them for injection into conversations
+*/
+/**
+* Read and clear pending context from daemon
+*/
+function consumePendingContext() {
+	const pendingPath = join(getStateRoot(), ".pending-context");
+	if (!existsSync(pendingPath)) return null;
+	try {
+		const content = readFileSync(pendingPath, "utf-8").trim();
+		unlinkSync(pendingPath);
+		return content || null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Initialize state directory structure (directories only, no default files)
+* Files are created during onboarding.
+*/
+function initializeStateRoot() {
+	const stateRoot = getStateRoot();
+	const dirs = [
+		stateRoot,
+		join(stateRoot, "state"),
+		join(stateRoot, "journal"),
+		join(stateRoot, "entities"),
+		join(stateRoot, "entities", "people"),
+		join(stateRoot, "entities", "projects"),
+		join(stateRoot, "topics")
+	];
+	for (const dir of dirs) {
+		if (!existsSync(dir)) {
+			mkdirSync(dir, { recursive: true });
+		}
+	}
+}
+function readFileOrEmpty(path) {
+	try {
+		if (existsSync(path)) {
+			return readFileSync(path, "utf-8");
+		}
+	} catch {}
+	return "";
+}
+function getRecentJournal(count) {
+	const entries = [];
+	const journalDir = getJournalDir();
+	if (!existsSync(journalDir)) return entries;
+	try {
+		const files = readdirSync(journalDir).filter((f) => f.endsWith(".jsonl")).sort().reverse();
+		for (const file of files) {
+			if (entries.length >= count) break;
+			const content = readFileSync(join(journalDir, file), "utf-8");
+			const lines = content.trim().split("\n").filter(Boolean);
+			for (const line of lines.reverse()) {
+				if (entries.length >= count) break;
+				try {
+					entries.push(JSON.parse(line));
+				} catch {}
+			}
+		}
+	} catch {}
+	return entries;
+}
+function getSchedules() {
+	const remindersDir = getRemindersDir();
+	if (!existsSync(remindersDir)) return [];
+	const schedules = [];
+	try {
+		const files = readdirSync(remindersDir).filter((f) => f.endsWith(".json"));
+		for (const file of files) {
+			try {
+				const content = readFileSync(join(remindersDir, file), "utf-8");
+				schedules.push(JSON.parse(content));
+			} catch {}
+		}
+	} catch {
+		return [];
+	}
+	return schedules;
+}
+/**
+* Format memory context for injection into conversation
+*/
+async function formatContextForPrompt(options = {}) {
+	const { forCompaction = false, client } = options;
+	const stateRoot = getStateRoot();
+	const identityPath = join(stateRoot, "state", "identity.md");
+	const isFirstRun = !existsSync(identityPath);
+	if (isFirstRun) {
+		if (forCompaction) return null;
+		const userInfo = detectUser();
+		return `[MACRODATA]
+
+## Status: First Run
+
+Memory is not yet configured. Load the \`macrodata-onboarding\` skill to set up.
+
+## Detected User Info
+
+\`\`\`json
+${JSON.stringify(userInfo, null, 2)}
+\`\`\`
+
+Use this pre-detected info during onboarding instead of running detection scripts.`;
+	}
+	const identity = readFileOrEmpty(identityPath);
+	const today = readFileOrEmpty(join(stateRoot, "state", "today.md"));
+	const human = readFileOrEmpty(join(stateRoot, "state", "human.md"));
+	const workspace = readFileOrEmpty(join(stateRoot, "state", "workspace.md"));
+	const journalEntries = getRecentJournal(forCompaction ? 10 : 5);
+	const journalFormatted = journalEntries.map((e) => {
+		const ts = new Date(e.timestamp);
+		const date = isNaN(ts.getTime()) ? "unknown" : ts.toLocaleDateString();
+		return `- [${e.topic}] ${e.content.split("\n")[0]} (${date})`;
+	}).join("\n");
+	const schedules = getSchedules();
+	const schedulesFormatted = schedules.length > 0 ? schedules.map((s) => `- ${s.description} (${s.type}: ${s.expression})`).join("\n") : "_No active schedules_";
+	const sections = [
+		`<macrodata-identity>\n${identity || "_Not configured_"}\n</macrodata-identity>`,
+		`<macrodata-today>\n${today || "_Empty_"}\n</macrodata-today>`,
+		`<macrodata-human>\n${human || "_Empty_"}\n</macrodata-human>`
+	];
+	if (workspace) {
+		sections.push(`<macrodata-workspace>\n${workspace}\n</macrodata-workspace>`);
+	}
+	sections.push(`<macrodata-journal>\n${journalFormatted || "_No entries_"}\n</macrodata-journal>`);
+	if (!forCompaction) {
+		sections.push(`<macrodata-schedules>\n${schedulesFormatted}\n</macrodata-schedules>`);
+		const stateDir = join(stateRoot, "state");
+		/* v8 ignore next -- unreachable: this path only runs post-first-run, which
+		means identity.md exists under stateDir, so stateDir always exists. */
+		const stateFiles = existsSync(stateDir) ? readdirSync(stateDir).filter((f) => f.endsWith(".md")).map((f) => `state/${f}`) : [];
+		const entitiesDir = join(stateRoot, "entities");
+		const entityFiles = [];
+		if (existsSync(entitiesDir)) {
+			for (const subdir of readdirSync(entitiesDir)) {
+				const dir = join(entitiesDir, subdir);
+				try {
+					/* v8 ignore next -- redundant guard: subdir came from readdirSync so it
+					exists, and a non-directory throws below and is caught, not skipped here. */
+					if (!existsSync(dir) || !readdirSync(dir)) continue;
+					for (const f of readdirSync(dir).filter((f) => f.endsWith(".md"))) {
+						entityFiles.push(`entities/${subdir}/${f}`);
+					}
+				} catch {}
+			}
+		}
+		const allFiles = [...stateFiles, ...entityFiles];
+		/* v8 ignore next -- unreachable: post-first-run always has state files
+		(identity.md etc.), so allFiles is never empty here. */
+		const filesFormatted = allFiles.length > 0 ? allFiles.map((f) => `- ${f}`).join("\n") : "_No files yet_";
+		const usagePath = new URL("../USAGE.md", import.meta.url).pathname;
+		/* v8 ignore next -- USAGE.md is always shipped alongside the built plugin,
+		so the empty-usage fallback is defensive only. */
+		const usage = existsSync(usagePath) ? readFileSync(usagePath, "utf-8").trim() : "";
+		/* v8 ignore next 3 -- usage is always populated (USAGE.md ships with the
+		plugin), so the no-usage skip is defensive only. */
+		if (usage) {
+			sections.push(`<macrodata-usage>\n${usage}\n</macrodata-usage>`);
+		}
+		sections.push(`<macrodata-files root="${stateRoot}">\n${filesFormatted}\n</macrodata-files>`);
+		if (client) {
+			try {
+				const { data } = await client.config.providers();
+				if (data?.providers) {
+					const allModels = [];
+					for (const provider of data.providers) {
+						if (provider.models) {
+							for (const [modelId, model] of Object.entries(provider.models)) {
+								const m = model;
+								if (/-\d{8}$/.test(modelId) || !m.capabilities?.toolcall) continue;
+								allModels.push({
+									fullId: `${provider.id}/${modelId}`,
+									family: m.family || `${provider.id}/${modelId}`,
+									releaseDate: m.release_date || "1970-01-01"
+								});
+							}
+						}
+					}
+					const byFamily = new Map();
+					for (const model of allModels) {
+						const existing = byFamily.get(model.family);
+						if (!existing || model.releaseDate > existing.releaseDate) {
+							byFamily.set(model.family, model);
+						}
+					}
+					const models = Array.from(byFamily.values()).map((m) => m.fullId).sort();
+					if (models.length > 0) {
+						sections.push(`<macrodata-models>\nAvailable models for scheduling: ${models.join(", ")}\n</macrodata-models>`);
+					}
+				}
+			} catch {}
+		}
+	}
+	return `<macrodata>\n${sections.join("\n\n")}\n</macrodata>`;
+}
+
+//#endregion
+export { consumePendingContext, formatContextForPrompt, getStateRoot, initializeStateRoot };

package/dist/opencode/conversations.js

@@ -0,0 +1,367 @@
+import { getStateRoot } from "../src/config.js";
+import "./context.js";
+import { embedBatch, embedQuery } from "../src/embeddings.js";
+import { logger } from "./logger.js";
+import { existsSync, mkdirSync } from "fs";
+import { basename, join } from "path";
+import { homedir } from "os";
+import { LocalIndex } from "vectra";
+import { DatabaseSync } from "node:sqlite";
+
+//#region opencode/conversations.ts
+/**
+* OpenCode Conversation Indexer
+*
+* Indexes past OpenCode sessions for semantic search.
+* Reads from the OpenCode SQLite database at ~/.local/share/opencode/opencode.db
+*
+* Schema (relevant tables):
+*   - session: id, project_id, title, time_created, time_updated, parent_id
+*   - message: id, session_id, time_created, data (JSON with role, agent, etc.)
+*   - part: id, message_id, session_id, data (JSON with type, text, etc.)
+*   - project: id, worktree
+*/
+const OPENCODE_DB_PATH = process.env.MACRODATA_OPENCODE_DB_PATH || join(homedir(), ".local", "share", "opencode", "opencode.db");
+let convIndex = null;
+function resetConversationIndexForTests() {
+	convIndex = null;
+}
+async function getConversationIndex() {
+	if (convIndex) return convIndex;
+	const stateRoot = getStateRoot();
+	const indexPath = join(stateRoot, ".index", "oc-conversations");
+	const indexDir = join(stateRoot, ".index");
+	if (!existsSync(indexDir)) {
+		mkdirSync(indexDir, { recursive: true });
+	}
+	convIndex = new LocalIndex(indexPath);
+	if (!await convIndex.isIndexCreated()) {
+		logger.log("Creating new conversation index...");
+		await convIndex.createIndex();
+	}
+	return convIndex;
+}
+/**
+* Open the OpenCode SQLite database (read-only)
+*/
+function openDb() {
+	if (!existsSync(OPENCODE_DB_PATH)) {
+		logger.log(`OpenCode database not found at ${OPENCODE_DB_PATH}`);
+		return null;
+	}
+	try {
+		return new DatabaseSync(OPENCODE_DB_PATH, { readOnly: true });
+	} catch (err) {
+		logger.error(`Failed to open OpenCode database: ${String(err)}`);
+		return null;
+	}
+}
+/**
+* Query exchanges from the SQLite database.
+*
+* This runs a single query that:
+* 1. Finds user messages (role = 'user') that aren't compaction summaries
+* 2. Finds the next assistant message in the same session
+* 3. Aggregates text parts for both user and assistant messages
+* 4. Joins to project for worktree path
+* 5. Excludes subtask sessions (parent_id IS NULL)
+*/
+function queryExchanges(db, sinceMs) {
+	const whereClause = sinceMs ? "AND m.time_created > ?" : "";
+	const params = sinceMs ? [sinceMs] : [];
+	const sql = `
+    WITH user_messages AS (
+      SELECT
+        m.id AS user_msg_id,
+        m.session_id,
+        m.time_created AS user_time,
+        m.data AS user_data,
+        -- Find the next assistant message by time in the same session
+        (
+          SELECT am.id FROM message am
+          WHERE am.session_id = m.session_id
+            AND am.time_created > m.time_created
+            AND json_extract(am.data, '$.role') = 'assistant'
+          ORDER BY am.time_created ASC
+          LIMIT 1
+        ) AS assistant_msg_id
+      FROM message m
+      JOIN session s ON s.id = m.session_id
+      WHERE json_extract(m.data, '$.role') = 'user'
+        AND s.parent_id IS NULL
+        ${whereClause}
+    )
+    SELECT
+      um.user_msg_id,
+      um.session_id,
+      um.user_time,
+      COALESCE(
+        GROUP_CONCAT(
+          CASE WHEN up.message_id = um.user_msg_id AND json_extract(up.data, '$.type') = 'text'
+            THEN json_extract(up.data, '$.text')
+          END,
+          '\n'
+        ),
+        ''
+      ) AS user_text,
+      COALESCE(
+        GROUP_CONCAT(
+          CASE WHEN up.message_id = um.assistant_msg_id AND json_extract(up.data, '$.type') = 'text'
+            THEN json_extract(up.data, '$.text')
+          END,
+          '\n'
+        ),
+        ''
+      ) AS assistant_text,
+      p.worktree,
+      s.directory
+    FROM user_messages um
+    LEFT JOIN part up ON up.message_id IN (um.user_msg_id, um.assistant_msg_id)
+    LEFT JOIN session s ON s.id = um.session_id
+    LEFT JOIN project p ON p.id = s.project_id
+    WHERE um.assistant_msg_id IS NOT NULL
+    GROUP BY um.user_msg_id
+    HAVING user_text != ''
+    ORDER BY um.user_time ASC
+  `;
+	try {
+		return db.prepare(sql).all(...params);
+	} catch (err) {
+		logger.error(`Query failed: ${String(err)}`);
+		throw err;
+	}
+}
+/**
+* Convert raw DB rows to ConversationExchange objects
+*/
+function rowsToExchanges(rows) {
+	return rows.map((row) => {
+		const worktree = row.worktree && row.worktree !== "/" ? row.worktree : "";
+		const directory = row.directory || "";
+		const projectPath = worktree || directory;
+		const name = projectPath ? basename(projectPath) : "";
+		const projectName = name || "unknown";
+		return {
+			id: `oc-${row.session_id}-${row.user_msg_id}`,
+			userPrompt: row.user_text.slice(0, 1e3),
+			assistantSummary: row.assistant_text.slice(0, 500),
+			project: projectName,
+			projectPath,
+			timestamp: new Date(row.user_time).toISOString(),
+			sessionId: row.session_id,
+			messageId: row.user_msg_id
+		};
+	});
+}
+let rebuildInProgress = null;
+/**
+* Rebuild conversation index from scratch
+*/
+async function rebuildConversationIndex() {
+	if (rebuildInProgress) {
+		logger.log("Conversation index rebuild already in progress, waiting...");
+		return rebuildInProgress;
+	}
+	rebuildInProgress = doRebuildConversationIndex();
+	try {
+		return await rebuildInProgress;
+	} finally {
+		rebuildInProgress = null;
+	}
+}
+async function doRebuildConversationIndex() {
+	logger.log("Rebuilding OpenCode conversation index...");
+	const startTime = Date.now();
+	const db = openDb();
+	if (!db) return { exchangeCount: 0 };
+	try {
+		const rows = queryExchanges(db);
+		const exchanges = rowsToExchanges(rows);
+		logger.log(`Found ${exchanges.length} exchanges`);
+		if (exchanges.length === 0) return { exchangeCount: 0 };
+		const texts = exchanges.map((e) => e.userPrompt);
+		logger.log(`Generating embeddings for ${texts.length} exchanges...`);
+		const vectors = await embedBatch(texts);
+		logger.log(`Embeddings generated, inserting into index...`);
+		convIndex = null;
+		const idx = await getConversationIndex();
+		if (await idx.isIndexCreated()) {
+			await idx.deleteIndex();
+		}
+		await idx.createIndex();
+		await idx.beginUpdate();
+		try {
+			for (let i = 0; i < exchanges.length; i++) {
+				const ex = exchanges[i];
+				await idx.upsertItem({
+					id: ex.id,
+					vector: vectors[i],
+					metadata: {
+						userPrompt: ex.userPrompt,
+						assistantSummary: ex.assistantSummary,
+						project: ex.project,
+						projectPath: ex.projectPath,
+						timestamp: ex.timestamp,
+						sessionId: ex.sessionId,
+						messageId: ex.messageId
+					}
+				});
+				/* v8 ignore next 3 -- progress log that only fires past 500 indexed
+				exchanges; seeding 500 real embedded rows per test is impractical and
+				the line has no behavioural effect. */
+				if (i > 0 && i % 500 === 0) {
+					logger.log(`  ...inserted ${i}/${exchanges.length}`);
+				}
+			}
+			await idx.endUpdate();
+		} catch (err) {
+			idx.cancelUpdate();
+			throw err;
+		}
+		const duration = Date.now() - startTime;
+		logger.log(`Conversation index rebuilt: ${exchanges.length} exchanges in ${duration}ms`);
+		return { exchangeCount: exchanges.length };
+	} catch (err) {
+		logger.error(`Conversation index rebuild failed: ${String(err)}`);
+		throw err;
+	} finally {
+		db.close();
+	}
+}
+/**
+* Time-based weight for scoring
+*/
+function getTimeWeight(timestamp) {
+	const ts = new Date(timestamp);
+	if (isNaN(ts.getTime())) return .5;
+	const age = Date.now() - ts.getTime();
+	const dayMs = 24 * 60 * 60 * 1e3;
+	if (age < 7 * dayMs) return 1;
+	if (age < 30 * dayMs) return .9;
+	if (age < 90 * dayMs) return .7;
+	if (age < 365 * dayMs) return .5;
+	return .3;
+}
+/**
+* Search past conversations
+*/
+async function searchConversations(query, options = {}) {
+	const { currentProject, limit = 5, projectOnly = false } = options;
+	const idx = await getConversationIndex();
+	const stats = await idx.listItems();
+	if (stats.length === 0) {
+		return [];
+	}
+	const queryVector = await embedQuery(query);
+	const results = await idx.queryItems(queryVector, query, limit * 3);
+	const searchResults = results.map((r) => {
+		const meta = r.item.metadata;
+		const exchange = {
+			id: r.item.id,
+			userPrompt: meta.userPrompt,
+			assistantSummary: meta.assistantSummary,
+			project: meta.project,
+			projectPath: meta.projectPath,
+			timestamp: meta.timestamp,
+			sessionId: meta.sessionId,
+			messageId: meta.messageId
+		};
+		let adjustedScore = r.score;
+		adjustedScore *= getTimeWeight(exchange.timestamp);
+		if (currentProject && exchange.projectPath === currentProject) {
+			adjustedScore *= 1.5;
+		}
+		return {
+			exchange,
+			score: r.score,
+			adjustedScore
+		};
+	});
+	let filtered = searchResults;
+	if (projectOnly && currentProject) {
+		filtered = searchResults.filter((r) => r.exchange.projectPath === currentProject);
+	}
+	return filtered.sort((a, b) => b.adjustedScore - a.adjustedScore).slice(0, limit);
+}
+/**
+* Get conversation index stats
+*/
+async function getConversationIndexStats() {
+	const idx = await getConversationIndex();
+	const items = await idx.listItems();
+	return { exchangeCount: items.length };
+}
+/**
+* Incrementally update conversation index (only new exchanges)
+*/
+async function updateConversationIndex() {
+	logger.log("Updating OpenCode conversation index...");
+	const startTime = Date.now();
+	const db = openDb();
+	if (!db) return {
+		newCount: 0,
+		totalCount: 0
+	};
+	try {
+		const idx = await getConversationIndex();
+		const existingItems = await idx.listItems();
+		const existingIds = new Set(existingItems.map((item) => item.id));
+		let latestMs = 0;
+		for (const item of existingItems) {
+			const meta = item.metadata;
+			if (meta.timestamp) {
+				const ms = new Date(meta.timestamp).getTime();
+				if (ms > latestMs) latestMs = ms;
+			}
+		}
+		const sinceMs = latestMs > 0 ? latestMs - 6e4 : undefined;
+		const rows = queryExchanges(db, sinceMs);
+		const allExchanges = rowsToExchanges(rows);
+		const newExchanges = allExchanges.filter((ex) => !existingIds.has(ex.id));
+		logger.log(`Found ${newExchanges.length} new exchanges (${existingIds.size} already indexed)`);
+		if (newExchanges.length === 0) {
+			return {
+				newCount: 0,
+				totalCount: existingIds.size
+			};
+		}
+		const texts = newExchanges.map((e) => e.userPrompt);
+		logger.log(`Generating embeddings for ${texts.length} new exchanges...`);
+		const vectors = await embedBatch(texts);
+		await idx.beginUpdate();
+		try {
+			for (let i = 0; i < newExchanges.length; i++) {
+				const ex = newExchanges[i];
+				await idx.upsertItem({
+					id: ex.id,
+					vector: vectors[i],
+					metadata: {
+						userPrompt: ex.userPrompt,
+						assistantSummary: ex.assistantSummary,
+						project: ex.project,
+						projectPath: ex.projectPath,
+						timestamp: ex.timestamp,
+						sessionId: ex.sessionId,
+						messageId: ex.messageId
+					}
+				});
+			}
+			await idx.endUpdate();
+		} catch (err) {
+			idx.cancelUpdate();
+			throw err;
+		}
+		const duration = Date.now() - startTime;
+		const totalCount = existingIds.size + newExchanges.length;
+		logger.log(`Added ${newExchanges.length} exchanges in ${duration}ms (total: ${totalCount})`);
+		return {
+			newCount: newExchanges.length,
+			totalCount
+		};
+	} finally {
+		db.close();
+	}
+}
+
+//#endregion
+export { getConversationIndexStats, queryExchanges, rebuildConversationIndex, resetConversationIndexForTests, searchConversations, updateConversationIndex };