suemo 0.0.1 → 0.0.3

package/src/mcp/dispatch.ts

@@ -0,0 +1,232 @@
+import type { Surreal } from 'surrealdb'
+import { z } from 'zod'
+import { consolidate } from '../cognitive/consolidate.ts'
+import { healthReport, suemoStats, vitals } from '../cognitive/health.ts'
+import type { SuemoConfig } from '../config.ts'
+import { goalList, goalResolve, goalSet } from '../goal.ts'
+import { getLogger } from '../logger.ts'
+import { episodeEnd, episodeStart, getSessionContext, setSessionContext } from '../memory/episode.ts'
+import { query, recall, timeline, wander } from '../memory/read.ts'
+import { believe, capturePrompt, invalidate, observe, upsertByKey } from '../memory/write.ts'
+import { ObserveInputSchema, QueryInputSchema } from '../types.ts'
+
+const log = getLogger(['suemo', 'mcp', 'dispatch'])
+
+const MUTATING_TOOLS = new Set([
+	'observe',
+	'believe',
+	'invalidate',
+	'goal_set',
+	'goal_resolve',
+	'upsert_by_key',
+	'capture_prompt',
+	'session_context_set',
+])
+
+interface DispatchOptions {
+	onMutation?: (tool: string) => Promise<void>
+}
+
+export async function handleToolCall(
+	db: Surreal,
+	config: SuemoConfig,
+	method: string,
+	params: Record<string, unknown>,
+	opts: DispatchOptions = {},
+): Promise<unknown> {
+	log.debug('Dispatching MCP tool call', { method, paramKeys: Object.keys(params) })
+
+	const maybeTriggerMutationSync = (): void => {
+		if (!MUTATING_TOOLS.has(method) || !opts.onMutation) return
+		void opts.onMutation(method).catch((error) => {
+			log.warning('Post-mutation hook failed', { method, error: String(error) })
+		})
+	}
+
+	switch (method) {
+		case 'observe': {
+			const result = await observe(db, ObserveInputSchema.parse(params), config)
+			maybeTriggerMutationSync()
+			return result
+		}
+
+		case 'believe': {
+			const parsed = z
+				.object({
+					content: z.string(),
+					scope: z.string().optional(),
+					confidence: z.number().optional(),
+				})
+				.parse(params)
+			const result = await believe(db, parsed, config)
+			maybeTriggerMutationSync()
+			return result
+		}
+
+		case 'invalidate': {
+			const parsed = z.object({ nodeId: z.string(), reason: z.string().optional() }).parse(params)
+			await invalidate(db, parsed.nodeId, parsed.reason)
+			maybeTriggerMutationSync()
+			return { ok: true }
+		}
+
+		case 'query':
+			return query(db, QueryInputSchema.parse(params), config)
+
+		case 'recall': {
+			const parsed = z.object({ nodeId: z.string() }).parse(params)
+			return recall(db, parsed.nodeId)
+		}
+
+		case 'wander': {
+			const parsed = z
+				.object({ anchor: z.string().optional(), hops: z.number().optional(), scope: z.string().optional() })
+				.parse(params)
+			return wander(db, {
+				...(parsed.anchor ? { anchor: parsed.anchor } : {}),
+				...(parsed.hops ? { hops: parsed.hops } : {}),
+				...(parsed.scope ? { scope: parsed.scope } : {}),
+			})
+		}
+
+		case 'timeline': {
+			const parsed = z
+				.object({
+					scope: z.string().optional(),
+					from: z.string().optional(),
+					until: z.string().optional(),
+					limit: z.number().optional(),
+				})
+				.parse(params)
+			return timeline(db, {
+				...(parsed.scope ? { scope: parsed.scope } : {}),
+				...(parsed.from ? { from: parsed.from } : {}),
+				...(parsed.until ? { until: parsed.until } : {}),
+				...(parsed.limit ? { limit: parsed.limit } : {}),
+			})
+		}
+
+		case 'episode_start': {
+			const parsed = z.object({ sessionId: z.string() }).parse(params)
+			return episodeStart(db, parsed.sessionId)
+		}
+
+		case 'episode_end': {
+			const parsed = z.object({ sessionId: z.string(), summary: z.string().optional() }).parse(params)
+			return episodeEnd(db, parsed.sessionId, parsed.summary)
+		}
+
+		case 'goal_set': {
+			const parsed = z
+				.object({ content: z.string(), scope: z.string().optional(), tags: z.array(z.string()).optional() })
+				.parse(params)
+			const result = await goalSet(db, parsed.content, config, {
+				...(parsed.scope ? { scope: parsed.scope } : {}),
+				tags: parsed.tags ?? [],
+			})
+			maybeTriggerMutationSync()
+			return result
+		}
+
+		case 'goal_resolve': {
+			const parsed = z.object({ goalId: z.string() }).parse(params)
+			await goalResolve(db, parsed.goalId)
+			maybeTriggerMutationSync()
+			return { ok: true }
+		}
+
+		case 'goal_list': {
+			const parsed = z.object({ scope: z.string().optional(), includeResolved: z.boolean().optional() }).parse(params)
+			return goalList(db, {
+				...(parsed.scope ? { scope: parsed.scope } : {}),
+				includeResolved: parsed.includeResolved ?? false,
+			})
+		}
+
+		case 'health':
+			return healthReport(db)
+
+		case 'stats':
+			return suemoStats(db)
+
+		case 'vitals':
+			return vitals(db)
+
+		case 'consolidate': {
+			const parsed = z.object({ nremOnly: z.boolean().optional() }).parse(params)
+			return consolidate(db, {
+				nremOnly: parsed.nremOnly ?? false,
+				nremSimilarityThreshold: config.consolidation.nremSimilarityThreshold,
+				remRelationThreshold: config.consolidation.remRelationThreshold,
+				llm: config.consolidation.llm,
+				embedding: config.embedding,
+			})
+		}
+
+		case 'upsert_by_key': {
+			const parsed = z
+				.object({
+					topicKey: z.string(),
+					content: z.string(),
+					scope: z.string().optional(),
+					tags: z.array(z.string()).optional(),
+					confidence: z.number().optional(),
+					source: z.string().optional(),
+					sessionId: z.string().optional(),
+					kind: z.enum(['observation', 'belief', 'question', 'hypothesis', 'goal']).optional(),
+				})
+				.parse(params)
+			const result = await upsertByKey(db, config, parsed.topicKey, parsed.content, {
+				...(parsed.scope ? { scope: parsed.scope } : {}),
+				tags: parsed.tags ?? [],
+				...(parsed.source ? { source: parsed.source } : {}),
+				...(parsed.sessionId ? { sessionId: parsed.sessionId } : {}),
+				confidence: parsed.confidence ?? 1.0,
+				...(parsed.kind ? { kind: parsed.kind } : {}),
+			})
+			maybeTriggerMutationSync()
+			return result
+		}
+
+		case 'capture_prompt': {
+			const parsed = z
+				.object({
+					prompt: z.string(),
+					derivedIds: z.array(z.string()).optional(),
+					scope: z.string().optional(),
+					sessionId: z.string().optional(),
+				})
+				.parse(params)
+			const result = await capturePrompt(db, config, parsed.prompt, parsed.derivedIds ?? [], {
+				...(parsed.scope ? { scope: parsed.scope } : {}),
+				...(parsed.sessionId ? { sessionId: parsed.sessionId } : {}),
+			})
+			maybeTriggerMutationSync()
+			return result
+		}
+
+		case 'session_context_get': {
+			const parsed = z.object({ sessionId: z.string() }).parse(params)
+			return getSessionContext(db, parsed.sessionId)
+		}
+
+		case 'session_context_set': {
+			const parsed = z
+				.object({
+					sessionId: z.string(),
+					summary: z.string().optional(),
+					context: z.record(z.string(), z.unknown()).optional(),
+				})
+				.parse(params)
+			await setSessionContext(db, parsed.sessionId, {
+				...(parsed.summary !== undefined ? { summary: parsed.summary } : {}),
+				...(parsed.context !== undefined ? { context: parsed.context } : {}),
+			})
+			maybeTriggerMutationSync()
+			return { ok: true }
+		}
+
+		default:
+			throw new Error(`Unknown MCP tool: ${method}`)
+	}
+}

package/src/mcp/server.ts

@@ -1,23 +1,169 @@
 // src/mcp/server.ts
 import { Elysia } from 'elysia'
-import type { SuemoConfig } from '../config.ts'
-import { connect } from '../db/client.ts'
-import { requireCompatibility } from '../db/preflight.ts'
+import { resolveSyncConfig, type SuemoConfig } from '../config.ts'
+import { connect, disconnect } from '../db/client.ts'
+import { checkCompatibility, requireCompatibility } from '../db/preflight.ts'
 import { runSchema } from '../db/schema.ts'
 import { getLogger } from '../logger.ts'
+import { syncTo } from '../sync.ts'
+import { runStdioServer } from './stdio.ts'
 import { buildMcpRouter } from './tools.ts'
 
 const log = getLogger(['suemo', 'mcp'])
 
+interface AutoSyncOptions {
+	reason: 'timer' | 'write'
+	force?: boolean
+}
+
+function createAutoSyncRunner(
+	db: ReturnType<typeof connect> extends Promise<infer T> ? T : never,
+	config: SuemoConfig,
+): {
+	start: () => void
+	onWrite: (tool: string) => Promise<void>
+	stop: () => void
+} {
+	const resolvedSync = resolveSyncConfig(config)
+	if (!resolvedSync) {
+		return {
+			start: () => {},
+			onWrite: async () => {},
+			stop: () => {},
+		}
+	}
+
+	let timer: ReturnType<typeof setInterval> | null = null
+	let running = false
+	let queued = false
+	let lastRunAt = 0
+
+	const runAutoSync = async ({ reason, force = false }: AutoSyncOptions): Promise<void> => {
+		if (!resolvedSync.auto.enabled) return
+		if (reason === 'write' && !resolvedSync.auto.onWrite) return
+
+		const now = Date.now()
+		const minIntervalMs = resolvedSync.auto.minWriteIntervalSeconds * 1000
+		if (!force && reason === 'write' && lastRunAt > 0 && now - lastRunAt < minIntervalMs) {
+			return
+		}
+
+		if (running) {
+			queued = true
+			return
+		}
+
+		const target = resolvedSync.remotes[resolvedSync.auto.remote]
+		if (!target) {
+			log.warning('Auto-sync skipped: remote missing', { remote: resolvedSync.auto.remote, reason })
+			return
+		}
+
+		running = true
+		try {
+			const result = await syncTo(db, target, {
+				direction: resolvedSync.auto.direction,
+			})
+			lastRunAt = Date.now()
+			log.info('Auto-sync completed', {
+				reason,
+				remote: resolvedSync.auto.remote,
+				direction: resolvedSync.auto.direction,
+				pushed: result.pushed,
+				errors: result.errors,
+			})
+		} catch (error) {
+			log.warning('Auto-sync failed', { reason, error: String(error) })
+		} finally {
+			running = false
+			if (queued) {
+				queued = false
+				queueMicrotask(() => {
+					void runAutoSync({ reason: 'write', force: true })
+				})
+			}
+		}
+	}
+
+	const start = (): void => {
+		if (!resolvedSync.auto.enabled) return
+		if (timer) return
+		const intervalMs = resolvedSync.auto.intervalSeconds * 1000
+		timer = setInterval(() => {
+			void runAutoSync({ reason: 'timer' })
+		}, intervalMs)
+		log.info('Auto-sync timer started', {
+			intervalSeconds: resolvedSync.auto.intervalSeconds,
+			remote: resolvedSync.auto.remote,
+			direction: resolvedSync.auto.direction,
+		})
+	}
+
+	const stop = (): void => {
+		if (!timer) return
+		clearInterval(timer)
+		timer = null
+		log.info('Auto-sync timer stopped')
+	}
+
+	const onWrite = async (tool: string): Promise<void> => {
+		if (!resolvedSync.auto.enabled || !resolvedSync.auto.onWrite) return
+		log.debug('Auto-sync write trigger', { tool })
+		await runAutoSync({ reason: 'write' })
+	}
+
+	return { start, onWrite, stop }
+}
+
 export async function startMcpServer(config: SuemoConfig): Promise<void> {
 	const db = await connect(config.surreal)
 	await requireCompatibility(db)
 	await runSchema(db)
+	const autoSync = createAutoSyncRunner(db, config)
+	autoSync.start()
+
+	const shutdown = async (): Promise<void> => {
+		autoSync.stop()
+		await disconnect()
+		process.exit(0)
+	}
+
+	process.once('SIGINT', () => {
+		void shutdown()
+	})
+	process.once('SIGTERM', () => {
+		void shutdown()
+	})
 
 	new Elysia()
-		.use(buildMcpRouter(db, config))
+		.use(buildMcpRouter(db, config, { onMutation: autoSync.onWrite }))
 		.get('/health', () => ({ status: 'ok' }))
 		.listen({ port: config.mcp.port, hostname: config.mcp.host })
 
 	log.info('MCP server listening', { port: config.mcp.port, host: config.mcp.host })
 }
+
+export async function startMcpStdioServer(config: SuemoConfig): Promise<void> {
+	const db = await connect(config.surreal)
+	const autoSync = createAutoSyncRunner(db, config)
+	autoSync.start()
+	try {
+		const compat = await checkCompatibility(db, {
+			requireEmbedding: config.embedding.provider === 'surreal',
+			context: 'mcp:stdio-startup',
+		})
+		if (!compat.ok) {
+			console.error('\n[suemo] Compatibility check failed:\n')
+			for (const err of compat.errors) {
+				console.error(`  ✗ ${err}`)
+			}
+			console.error('\nFix the issues above and retry.\n')
+			process.exit(1)
+		}
+		await runSchema(db)
+		await runStdioServer(db, config, { onMutation: autoSync.onWrite })
+	} finally {
+		autoSync.stop()
+		await disconnect()
+	}
+}