suemo 0.0.1 → 0.0.2

package/src/mcp/dispatch.ts

@@ -0,0 +1,134 @@
+import type { Surreal } from 'surrealdb'
+import { z } from 'zod'
+import { consolidate } from '../cognitive/consolidate.ts'
+import { healthReport, 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 } from '../memory/episode.ts'
+import { query, recall, timeline, wander } from '../memory/read.ts'
+import { believe, invalidate, observe } from '../memory/write.ts'
+import { ObserveInputSchema, QueryInputSchema } from '../types.ts'
+
+const log = getLogger(['suemo', 'mcp', 'dispatch'])
+
+export async function handleToolCall(
+	db: Surreal,
+	config: SuemoConfig,
+	method: string,
+	params: Record<string, unknown>,
+): Promise<unknown> {
+	log.debug('Dispatching MCP tool call', { method, paramKeys: Object.keys(params) })
+
+	switch (method) {
+		case 'observe':
+			return observe(db, ObserveInputSchema.parse(params), config)
+
+		case 'believe': {
+			const parsed = z
+				.object({
+					content: z.string(),
+					scope: z.string().optional(),
+					confidence: z.number().optional(),
+				})
+				.parse(params)
+			return believe(db, parsed, config)
+		}
+
+		case 'invalidate': {
+			const parsed = z.object({ nodeId: z.string(), reason: z.string().optional() }).parse(params)
+			await invalidate(db, parsed.nodeId, parsed.reason)
+			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)
+			return goalSet(db, parsed.content, config, {
+				...(parsed.scope ? { scope: parsed.scope } : {}),
+				tags: parsed.tags ?? [],
+			})
+		}
+
+		case 'goal_resolve': {
+			const parsed = z.object({ goalId: z.string() }).parse(params)
+			await goalResolve(db, parsed.goalId)
+			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 '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,
+			})
+		}
+
+		default:
+			throw new Error(`Unknown MCP tool: ${method}`)
+	}
+}

package/src/mcp/server.ts

@@ -1,10 +1,11 @@
 // 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 { 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 { runStdioServer } from './stdio.ts'
 import { buildMcpRouter } from './tools.ts'
 
 const log = getLogger(['suemo', 'mcp'])
@@ -21,3 +22,25 @@ export async function startMcpServer(config: SuemoConfig): Promise<void> {
 
 	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)
+	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)
+	} finally {
+		await disconnect()
+	}
+}

package/src/mcp/stdio.ts

@@ -0,0 +1,314 @@
+import { createInterface } from 'node:readline'
+import type { Surreal } from 'surrealdb'
+import type { SuemoConfig } from '../config.ts'
+import { getLogger } from '../logger.ts'
+import { handleToolCall } from './dispatch.ts'
+
+const log = getLogger(['suemo', 'mcp', 'stdio'])
+
+interface JsonRpcRequest {
+	jsonrpc?: string
+	id?: unknown
+	method?: unknown
+	params?: unknown
+}
+
+interface McpToolDefinition {
+	name: string
+	description: string
+	inputSchema: Record<string, unknown>
+}
+
+const SUPPORTED_PROTOCOL_VERSIONS = new Set(['2024-11-05', '2025-03-26'])
+const DEFAULT_PROTOCOL_VERSION = '2024-11-05'
+
+const MCP_TOOLS: McpToolDefinition[] = [
+	{
+		name: 'observe',
+		description: 'Store an observation/belief/question/hypothesis/goal memory node',
+		inputSchema: {
+			type: 'object',
+			properties: {
+				content: { type: 'string' },
+				kind: { type: 'string' },
+				tags: { type: 'array', items: { type: 'string' } },
+				scope: { type: 'string' },
+				source: { type: 'string' },
+				confidence: { type: 'number' },
+			},
+			required: ['content'],
+		},
+	},
+	{
+		name: 'believe',
+		description: 'Store a belief and run contradiction detection',
+		inputSchema: {
+			type: 'object',
+			properties: {
+				content: { type: 'string' },
+				scope: { type: 'string' },
+				confidence: { type: 'number' },
+			},
+			required: ['content'],
+		},
+	},
+	{
+		name: 'invalidate',
+		description: 'Invalidate a memory node (soft-delete via valid_until)',
+		inputSchema: {
+			type: 'object',
+			properties: {
+				nodeId: { type: 'string' },
+				reason: { type: 'string' },
+			},
+			required: ['nodeId'],
+		},
+	},
+	{
+		name: 'query',
+		description: 'Hybrid semantic retrieval over memory nodes',
+		inputSchema: {
+			type: 'object',
+			properties: {
+				input: { type: 'string' },
+				scope: { type: 'string' },
+				kind: { type: 'array', items: { type: 'string' } },
+				topK: { type: 'number' },
+				activeOnly: { type: 'boolean' },
+				strategies: { type: 'array', items: { type: 'string' } },
+			},
+			required: ['input'],
+		},
+	},
+	{
+		name: 'recall',
+		description: 'Fetch one node and neighbors; tick review schedule',
+		inputSchema: {
+			type: 'object',
+			properties: { nodeId: { type: 'string' } },
+			required: ['nodeId'],
+		},
+	},
+	{
+		name: 'wander',
+		description: 'Traverse graph via spreading activation',
+		inputSchema: {
+			type: 'object',
+			properties: {
+				anchor: { type: 'string' },
+				hops: { type: 'number' },
+				scope: { type: 'string' },
+			},
+		},
+	},
+	{
+		name: 'timeline',
+		description: 'Get chronological memory slice',
+		inputSchema: {
+			type: 'object',
+			properties: {
+				scope: { type: 'string' },
+				from: { type: 'string' },
+				until: { type: 'string' },
+				limit: { type: 'number' },
+			},
+		},
+	},
+	{
+		name: 'episode_start',
+		description: 'Start an episode for a session ID',
+		inputSchema: {
+			type: 'object',
+			properties: { sessionId: { type: 'string' } },
+			required: ['sessionId'],
+		},
+	},
+	{
+		name: 'episode_end',
+		description: 'End an episode for a session ID',
+		inputSchema: {
+			type: 'object',
+			properties: {
+				sessionId: { type: 'string' },
+				summary: { type: 'string' },
+			},
+			required: ['sessionId'],
+		},
+	},
+	{
+		name: 'goal_set',
+		description: 'Create goal node',
+		inputSchema: {
+			type: 'object',
+			properties: {
+				content: { type: 'string' },
+				scope: { type: 'string' },
+				tags: { type: 'array', items: { type: 'string' } },
+			},
+			required: ['content'],
+		},
+	},
+	{
+		name: 'goal_resolve',
+		description: 'Resolve a goal by ID',
+		inputSchema: {
+			type: 'object',
+			properties: { goalId: { type: 'string' } },
+			required: ['goalId'],
+		},
+	},
+	{
+		name: 'goal_list',
+		description: 'List goals',
+		inputSchema: {
+			type: 'object',
+			properties: {
+				scope: { type: 'string' },
+				includeResolved: { type: 'boolean' },
+			},
+		},
+	},
+	{
+		name: 'health',
+		description: 'Get health report',
+		inputSchema: { type: 'object', properties: {} },
+	},
+	{
+		name: 'vitals',
+		description: 'Get health vitals summary',
+		inputSchema: { type: 'object', properties: {} },
+	},
+	{
+		name: 'consolidate',
+		description: 'Trigger memory consolidation',
+		inputSchema: {
+			type: 'object',
+			properties: { nremOnly: { type: 'boolean' } },
+		},
+	},
+]
+
+export async function runStdioServer(db: Surreal, config: SuemoConfig): Promise<void> {
+	log.info('MCP stdio transport started')
+
+	const rl = createInterface({ input: process.stdin, terminal: false })
+
+	try {
+		for await (const line of rl) {
+			if (!line.trim()) continue
+
+			let request: JsonRpcRequest
+			try {
+				request = JSON.parse(line) as JsonRpcRequest
+			} catch {
+				writeJsonRpc({
+					jsonrpc: '2.0',
+					id: null,
+					error: { code: -32700, message: 'Parse error' },
+				})
+				continue
+			}
+
+			const id = request.id ?? null
+			const method = typeof request.method === 'string' ? request.method : null
+			const params = request.params && typeof request.params === 'object' && !Array.isArray(request.params)
+				? request.params as Record<string, unknown>
+				: {}
+
+			if (!method) {
+				writeJsonRpc({
+					jsonrpc: '2.0',
+					id,
+					error: { code: -32600, message: 'Invalid Request: method must be a string' },
+				})
+				continue
+			}
+
+			log.debug('Received stdio MCP request', { method })
+
+			try {
+				const result = await handleRpcMethod(db, config, method, params)
+				if (id === null) continue
+				writeJsonRpc({ jsonrpc: '2.0', id, result })
+			} catch (error) {
+				if (id === null) continue
+				writeJsonRpc({
+					jsonrpc: '2.0',
+					id,
+					error: { code: -32603, message: String(error) },
+				})
+			}
+		}
+	} finally {
+		rl.close()
+	}
+
+	log.info('stdin closed — stdio server exiting')
+}
+
+async function handleRpcMethod(
+	db: Surreal,
+	config: SuemoConfig,
+	method: string,
+	params: Record<string, unknown>,
+): Promise<unknown> {
+	if (method === 'initialize' || method === 'initiaize') {
+		const requestedVersion = typeof params.protocolVersion === 'string'
+			? params.protocolVersion
+			: DEFAULT_PROTOCOL_VERSION
+		const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.has(requestedVersion)
+			? requestedVersion
+			: DEFAULT_PROTOCOL_VERSION
+
+		return {
+			protocolVersion,
+			capabilities: {
+				tools: { listChanged: false },
+			},
+			serverInfo: {
+				name: 'suemo',
+				version: '0.0.1',
+			},
+		}
+	}
+
+	if (method === 'notifications/initialized') {
+		return {}
+	}
+
+	if (method === 'ping') {
+		return {}
+	}
+
+	if (method === 'tools/list') {
+		return { tools: MCP_TOOLS }
+	}
+
+	if (method === 'tools/call') {
+		const name = typeof params.name === 'string' ? params.name : null
+		if (!name) {
+			throw new Error('Invalid tools/call params: missing string field `name`')
+		}
+
+		const toolArgs = params.arguments && typeof params.arguments === 'object' && !Array.isArray(params.arguments)
+			? params.arguments as Record<string, unknown>
+			: {}
+
+		const toolResult = await handleToolCall(db, config, name, toolArgs)
+		return {
+			content: [{ type: 'text', text: JSON.stringify(toolResult, null, 2) }],
+			structuredContent: toolResult,
+		}
+	}
+
+	// Backward-compatible direct tool method invocation.
+	if (MCP_TOOLS.some((t) => t.name === method)) {
+		return handleToolCall(db, config, method, params)
+	}
+
+	throw new Error(`Unknown MCP method: ${method}`)
+}
+
+function writeJsonRpc(payload: unknown): void {
+	process.stdout.write(`${JSON.stringify(payload)}\n`)
+}

package/src/mcp/tools.ts

@@ -1,100 +1,19 @@
 // src/mcp/tools.ts
-// Each tool: parse input with Zod → call domain fn → return result.
-// No business logic here. SSoT lives in domain modules.
+// HTTP transport adapter for MCP calls.
 
 import type { Elysia } from 'elysia'
 import type { Surreal } from 'surrealdb'
-import { z } from 'zod'
-import { consolidate } from '../cognitive/consolidate.ts'
-import { healthReport, vitals } from '../cognitive/health.ts'
 import type { SuemoConfig } from '../config.ts'
-import { goalList, goalResolve, goalSet } from '../goal.ts'
-import { episodeEnd, episodeStart } from '../memory/episode.ts'
-import { query, recall, timeline, wander } from '../memory/read.ts'
-import { believe, invalidate, observe } from '../memory/write.ts'
-import { ObserveInputSchema, QueryInputSchema } from '../types.ts'
+import { handleToolCall } from './dispatch.ts'
 
 export function buildMcpRouter(db: Surreal, config: SuemoConfig) {
-	// Returns an Elysia plugin that adds all /mcp/* routes.
-	// Each route maps 1:1 to a domain function.
+	// Elysia plugin: route-level transport, shared dispatch handles behavior.
 	return (app: Elysia) =>
 		app
-			.post('/mcp/observe', async ({ body }) => observe(db, ObserveInputSchema.parse(body)))
-			.post('/mcp/believe', async ({ body }) => {
-				const p = z.object({ content: z.string(), scope: z.string().optional(), confidence: z.number().optional() })
-					.parse(body)
-				return believe(db, p)
-			})
-			.post('/mcp/invalidate', async ({ body }) => {
-				const p = z.object({ nodeId: z.string(), reason: z.string().optional() }).parse(body)
-				await invalidate(db, p.nodeId, p.reason)
-				return { ok: true }
-			})
-			.post('/mcp/query', async ({ body }) => query(db, QueryInputSchema.parse(body)))
-			.post('/mcp/recall', async ({ body }) => {
-				const p = z.object({ nodeId: z.string() }).parse(body)
-				return recall(db, p.nodeId)
-			})
-			.post('/mcp/wander', async ({ body }) => {
-				const p = z.object({ anchor: z.string().optional(), hops: z.number().optional(), scope: z.string().optional() })
-					.parse(body)
-				return wander(db, {
-					...(p.anchor ? { anchor: p.anchor } : {}),
-					...(p.hops ? { hops: p.hops } : {}),
-					...(p.scope ? { scope: p.scope } : {}),
-				})
-			})
-			.post('/mcp/timeline', async ({ body }) => {
-				const p = z.object({
-					scope: z.string().optional(),
-					from: z.string().optional(),
-					until: z.string().optional(),
-					limit: z.number().optional(),
-				}).parse(body)
-				return timeline(db, {
-					...(p.scope ? { scope: p.scope } : {}),
-					...(p.from ? { from: p.from } : {}),
-					...(p.until ? { until: p.until } : {}),
-					...(p.limit ? { limit: p.limit } : {}),
-				})
-			})
-			.post('/mcp/episode_start', async ({ body }) => {
-				const p = z.object({ sessionId: z.string() }).parse(body)
-				return episodeStart(db, p.sessionId)
-			})
-			.post('/mcp/episode_end', async ({ body }) => {
-				const p = z.object({ sessionId: z.string(), summary: z.string().optional() }).parse(body)
-				return episodeEnd(db, p.sessionId, p.summary)
-			})
-			.post('/mcp/goal_set', async ({ body }) => {
-				const p = z.object({ content: z.string(), scope: z.string().optional(), tags: z.array(z.string()).optional() })
-					.parse(body)
-				return goalSet(db, p.content, {
-					...(p.scope ? { scope: p.scope } : {}),
-					tags: p.tags ?? [],
-				})
-			})
-			.post('/mcp/goal_resolve', async ({ body }) => {
-				const p = z.object({ goalId: z.string() }).parse(body)
-				await goalResolve(db, p.goalId)
-				return { ok: true }
-			})
-			.post('/mcp/goal_list', async ({ body }) => {
-				const p = z.object({ scope: z.string().optional(), includeResolved: z.boolean().optional() }).parse(body)
-				return goalList(db, {
-					...(p.scope ? { scope: p.scope } : {}),
-					includeResolved: p.includeResolved ?? false,
-				})
-			})
-			.get('/mcp/health', async () => healthReport(db))
-			.get('/mcp/vitals', async () => vitals(db))
-			.post('/mcp/consolidate', async ({ body }) => {
-				const p = z.object({ nremOnly: z.boolean().optional() }).parse(body ?? {})
-				return consolidate(db, {
-					nremOnly: p.nremOnly ?? false,
-					nremSimilarityThreshold: config.consolidation.nremSimilarityThreshold,
-					remRelationThreshold: config.consolidation.remRelationThreshold,
-					llm: config.consolidation.llm,
-				})
+			.post('/mcp/:tool', async ({ params, body }) => {
+				const payload = body && typeof body === 'object' && !Array.isArray(body)
+					? body as Record<string, unknown>
+					: {}
+				return handleToolCall(db, config, params.tool, payload)
 			})
 }