suemo 0.0.1

package/src/sync.ts

@@ -0,0 +1,120 @@
+import { createNodeEngines } from '@surrealdb/node'
+import { createHash } from 'node:crypto'
+import { createRemoteEngines, Surreal } from 'surrealdb'
+import type { SurrealTarget } from './config.ts'
+import { getLogger } from './logger.ts'
+import type { SyncResult } from './types.ts'
+
+const log = getLogger(['suemo', 'sync'])
+
+const BATCH_SIZE = 500
+
+function remoteKey(target: SurrealTarget): string {
+	return createHash('sha1')
+		.update(`${target.url}|${target.namespace}|${target.database}`)
+		.digest('hex')
+		.slice(0, 16)
+}
+
+export async function syncTo(
+	sourceDb: Surreal,
+	target: SurrealTarget,
+	opts: { dryRun?: boolean } = {},
+): Promise<SyncResult> {
+	log.info('syncTo()', { target: `${target.url}/${target.namespace}/${target.database}`, dryRun: opts.dryRun })
+
+	// Load cursor (last successfully synced created_at)
+	const key = remoteKey(target)
+	const cursorResult = await sourceDb.query<[{ cursor: string }[]]>(
+		`
+    SELECT cursor FROM sync_cursor WHERE remote_key = $key LIMIT 1
+  `,
+		{ key },
+	)
+	const cursor = cursorResult[0]?.[0]?.cursor ?? '1970-01-01T00:00:00Z'
+
+	log.info('Sync cursor', { cursor })
+
+	// Connect to remote
+	const remoteDb = new Surreal({
+		engines: {
+			...createRemoteEngines(),
+			...createNodeEngines(),
+		},
+	})
+	await remoteDb.connect(target.url, {
+		namespace: target.namespace,
+		database: target.database,
+		authentication: () => ({
+			username: target.auth.user,
+			password: target.auth.pass,
+		}),
+	})
+
+	let pushed = 0
+	let skipped = 0
+	let errors = 0
+	let latestCreatedAt = cursor
+
+	try {
+		let offset = 0
+
+		while (true) {
+			const batch = await sourceDb.query<[{ id: string; created_at: string; [k: string]: unknown }[]]>(
+				`
+        SELECT * FROM memory
+        WHERE created_at > <datetime>$cursor
+        ORDER BY created_at ASC
+        LIMIT $limit START $offset
+      `,
+				{ cursor, limit: BATCH_SIZE, offset },
+			)
+
+			const rows = batch[0] ?? []
+			if (rows.length === 0) break
+
+			for (const row of rows) {
+				if (opts.dryRun) {
+					log.debug('dry-run: would push', { id: row['id'] })
+					skipped++
+				} else {
+					try {
+						// INSERT IGNORE: if the ID already exists on remote, skip it
+						await remoteDb.query('INSERT IGNORE INTO memory $row', { row })
+						pushed++
+					} catch (e) {
+						log.error('Failed to push record', { id: row['id'], error: String(e) })
+						errors++
+					}
+				}
+				if (row['created_at'] && row['created_at'] > latestCreatedAt) {
+					latestCreatedAt = row['created_at']
+				}
+			}
+
+			offset += rows.length
+			if (rows.length < BATCH_SIZE) break
+		}
+
+		// Also sync relations
+		// (similar batching logic; omitted for brevity — same pattern with relates_to table)
+
+		if (!opts.dryRun && pushed > 0) {
+			// Advance cursor
+			await sourceDb.query(
+				`
+        UPSERT sync_cursor SET
+          remote_key  = $key,
+          cursor      = <datetime>$cursor,
+          last_synced = time::now()
+      `,
+				{ key, cursor: latestCreatedAt },
+			)
+		}
+	} finally {
+		await remoteDb.close()
+	}
+
+	log.info('syncTo() complete', { pushed, skipped, errors })
+	return { pushed, skipped, errors, cursor: latestCreatedAt }
+}

package/src/types.ts

@@ -0,0 +1,144 @@
+// Zod v4 (^4.3.6): import from "zod" root — package root now exports v4.
+// Key v4 behavior relevant here: .default() always applies even for absent keys.
+import { z } from 'zod'
+
+// ── Memory kinds ─────────────────────────────────────────────────────────────
+export const MemoryKindSchema = z.enum([
+	'observation',
+	'belief',
+	'question',
+	'hypothesis',
+	'goal',
+])
+export type MemoryKind = z.infer<typeof MemoryKindSchema>
+
+// ── Relation kinds ───────────────────────────────────────────────────────────
+export const RelationKindSchema = z.enum([
+	'supports',
+	'contradicts',
+	'derived_from',
+	'caused_by',
+	'similar_to',
+	'updates',
+	'sequential',
+])
+export type RelationKind = z.infer<typeof RelationKindSchema>
+
+// ── Core memory node (matches DB schema exactly) ─────────────────────────────
+export const MemoryNodeSchema = z.object({
+	id: z.string(),
+	kind: MemoryKindSchema,
+	content: z.string(),
+	summary: z.string().nullable(),
+	tags: z.array(z.string()),
+	scope: z.string().nullable(),
+	embedding: z.array(z.number()),
+	confidence: z.number().min(0).max(1),
+	salience: z.number().min(0).max(1),
+	valid_from: z.iso.datetime(),
+	valid_until: z.iso.datetime().nullable(),
+	source: z.string().nullable(),
+	created_at: z.iso.datetime(),
+	updated_at: z.iso.datetime(),
+	consolidated: z.boolean(),
+	consolidated_into: z.string().nullable(), // record ID string
+	fsrs_stability: z.number().nullable(),
+	fsrs_difficulty: z.number().nullable(),
+	fsrs_next_review: z.iso.datetime().nullable(),
+})
+export type MemoryNode = z.infer<typeof MemoryNodeSchema>
+
+// ── Relation edge ─────────────────────────────────────────────────────────────
+export const RelationSchema = z.object({
+	id: z.string(),
+	in: z.string(), // memory record ID
+	out: z.string(), // memory record ID
+	kind: RelationKindSchema,
+	strength: z.number().min(0).max(1),
+	valid_from: z.iso.datetime(),
+	valid_until: z.iso.datetime().nullable(),
+	created_at: z.iso.datetime(),
+})
+export type Relation = z.infer<typeof RelationSchema>
+
+// ── Episode ───────────────────────────────────────────────────────────────────
+export const EpisodeSchema = z.object({
+	id: z.string(),
+	session_id: z.string(),
+	started_at: z.iso.datetime(),
+	ended_at: z.iso.datetime().nullable(),
+	summary: z.string().nullable(),
+	memory_ids: z.array(z.string()),
+})
+export type Episode = z.infer<typeof EpisodeSchema>
+
+// ── Consolidation run log ────────────────────────────────────────────────────
+export const ConsolidationRunSchema = z.object({
+	id: z.string(),
+	started_at: z.iso.datetime(),
+	completed_at: z.iso.datetime().nullable(),
+	phase: z.enum(['nrem', 'rem', 'full']),
+	nodes_in: z.number().int(),
+	nodes_out: z.number().int(),
+	status: z.enum(['running', 'done', 'failed']),
+	error: z.string().nullable(),
+})
+export type ConsolidationRun = z.infer<typeof ConsolidationRunSchema>
+
+// ── observe() input ───────────────────────────────────────────────────────────
+// NOTE: no valid_from, valid_until — system-managed only, never in inputs
+// Zod v4: .default() on a field applies the default even when the key is absent
+// from input — this is the intended behavior for all optional fields here.
+export const ObserveInputSchema = z.object({
+	content: z.string().min(1),
+	kind: MemoryKindSchema.default('observation').optional(),
+	tags: z.array(z.string()).default([]).optional(),
+	scope: z.string().optional(),
+	source: z.string().optional(),
+	confidence: z.number().min(0).max(1).default(1.0).optional(),
+})
+export type ObserveInput = z.infer<typeof ObserveInputSchema>
+
+// ── query() input ─────────────────────────────────────────────────────────────
+export const QueryInputSchema = z.object({
+	input: z.string().min(1),
+	scope: z.string().optional(),
+	kind: z.array(MemoryKindSchema).optional(),
+	topK: z.number().int().min(1).max(50).default(5).optional(),
+	activeOnly: z.boolean().default(true).optional(),
+	strategies: z
+		.array(z.enum(['vector', 'bm25', 'graph', 'temporal']))
+		.default(['vector', 'bm25', 'graph'])
+		.optional(),
+})
+export type QueryInput = z.infer<typeof QueryInputSchema>
+
+// ── Health report ─────────────────────────────────────────────────────────────
+export const HealthReportSchema = z.object({
+	nodes: z.object({
+		total: z.number(),
+		active: z.number(),
+		consolidated: z.number(),
+		by_kind: z.record(z.string(), z.number()),
+		by_scope: z.record(z.string(), z.number()),
+	}),
+	relations: z.number(),
+	goals_active: z.number(),
+	fsrs_due: z.number(),
+	last_consolidation: ConsolidationRunSchema.nullable(),
+	version_check: z.object({
+		surreal_version: z.string(),
+		surrealkv: z.boolean(),
+		retention_ok: z.boolean(), // SURREAL_DATASTORE_RETENTION >= 90d on the server
+	}),
+})
+export type HealthReport = z.infer<typeof HealthReportSchema>
+
+// ── Sync result ───────────────────────────────────────────────────────────────
+export const SyncResultSchema = z.object({
+	pushed: z.number(),
+	skipped: z.number(),
+	errors: z.number(),
+	cursor: z.iso.datetime(),
+})
+export type SyncResult = z.infer<typeof SyncResultSchema>