suemo 0.0.1 → 0.0.2

package/src/memory/read.ts

@@ -1,4 +1,6 @@
 import type { Surreal } from 'surrealdb'
+import type { SuemoConfig } from '../config.ts'
+import { getEmbedding } from '../embedding/index.ts'
 import { getLogger } from '../logger.ts'
 import type { MemoryNode, QueryInput } from '../types.ts'
 import { QueryInputSchema } from '../types.ts'
@@ -11,35 +13,70 @@ const ACTIVE_FILTER = '(valid_until = NONE OR valid_until > time::now())'
 export async function query(
 	db: Surreal,
 	rawInput: QueryInput,
+	config: SuemoConfig,
 ): Promise<MemoryNode[]> {
 	const input = QueryInputSchema.parse(rawInput)
 	log.info('query()', { input: input.input, strategies: input.strategies, topK: input.topK })
 
-	const weights = { vector: 0.5, bm25: 0.25, graph: 0.15, temporal: 0.1 } // from config ideally
+	const weights = config.retrieval.weights
 
 	const topK = input.topK ?? 5
 	const strategies = input.strategies ?? ['vector', 'bm25', 'graph']
 	const candidateK = topK * 4 // over-fetch before reranking
+	const vectorProbeK = Math.max(1, Math.min(200, candidateK))
+	const vectorProbeEF = Math.max(40, vectorProbeK * 2)
 	const activeFilter = input.activeOnly ? ACTIVE_FILTER : 'true'
 	const scopeFilter = '($scope = NONE OR scope = $scope)'
 	const kindFilter = '($kinds = NONE OR kind INSIDE $kinds)'
+	const needsQueryEmbedding = strategies.includes('vector') || strategies.includes('bm25')
+		|| strategies.includes('graph')
+
+	let vectorExpr = 'fn::embed($queryText)'
+	let embeddingParam: number[] | undefined
+	if (needsQueryEmbedding) {
+		const embedding = await getEmbedding(input.input, config.embedding)
+		vectorExpr = embedding.clause === 'fn::embed($content)'
+			? 'fn::embed($queryText)'
+			: embedding.clause
+		embeddingParam = embedding.param
+		log.debug('query embedding resolved', {
+			provider: config.embedding.provider,
+			hasVectorParam: Boolean(embeddingParam),
+			dimension: embeddingParam?.length,
+			strategies,
+		})
+	}
 
 	const params = {
 		queryText: input.input,
 		scope: input.scope ?? null,
 		kinds: input.kind ?? null,
-		topK: input.topK,
 		candidateK,
+		...(embeddingParam ? { embedding: embeddingParam } : {}),
 	}
 
 	const promises: Promise<MemoryNode[]>[] = []
 
 	// ── Strategy A: RRF — vector + BM25 combined (one SurrealDB round trip) ──
 	if (strategies.includes('vector') || strategies.includes('bm25')) {
+		log.debug('query vector/bm25 strategy enabled', {
+			vectorProbeK,
+			vectorProbeEF,
+			weights: { vector: weights.vector, bm25: weights.bm25 },
+		})
 		promises.push(
 			db.query<[MemoryNode[]]>(
 				`
-      LET $vec = fn::embed($queryText);
+      LET $vec = ${vectorExpr};
+      LET $vecCand = (
+        SELECT id, embedding
+        FROM memory
+        WHERE ${activeFilter}
+          AND ${scopeFilter}
+          AND ${kindFilter}
+          AND embedding <|${vectorProbeK}, ${vectorProbeEF}|> $vec
+      );
+
       SELECT *,
         (
           search::score(1) * ${weights.bm25} +
@@ -47,7 +84,7 @@ export async function query(
         ) AS _score
       FROM memory
       WHERE content @1@ $queryText
-        AND embedding <|$candidateK, 40|> $vec
+        AND id INSIDE $vecCand.id
         AND ${activeFilter}
         AND ${scopeFilter}
         AND ${kindFilter}
@@ -62,16 +99,27 @@ export async function query(
 	// ── Strategy B: Graph spreading activation ───────────────────────────────
 	if (strategies.includes('graph')) {
 		// First get anchor IDs from a quick vector probe, then fan out via graph
+		log.debug('query graph strategy enabled', {
+			weights: { graph: weights.graph },
+		})
 		promises.push(
 			db.query<[MemoryNode[]]>(
 				`
-      LET $vec = fn::embed($queryText);
-      LET $anchors = (
-        SELECT id FROM memory
+      LET $vec = ${vectorExpr};
+      LET $anchor_cand = (
+        SELECT id, embedding
+        FROM memory
         WHERE ${activeFilter}
-        ORDER BY embedding <|5, 20|> $vec
+          AND embedding <|5, 20|> $vec
+      );
+
+      LET $anchor_rows = (
+        SELECT id, embedding, vector::similarity::cosine(embedding, $vec) AS _score
+        FROM $anchor_cand
+        ORDER BY _score DESC
         LIMIT 5
-      ).id;
+      );
+      LET $anchors = $anchor_rows.id;
       SELECT *,
         math::mean(<-relates_to[WHERE valid_until = NONE OR valid_until > time::now()].strength) AS _score
       FROM memory
@@ -112,7 +160,7 @@ export async function query(
 			((b as Record<string, unknown>)['_score'] as number ?? 0)
 			- ((a as Record<string, unknown>)['_score'] as number ?? 0)
 		)
-		.slice(0, input.topK)
+		.slice(0, topK)
 		.map(({ ...rest }) => {
 			delete (rest as Record<string, unknown>)['_score']
 			return rest as MemoryNode
@@ -130,13 +178,16 @@ export async function recall(
 	log.info('recall()', { nodeId })
 
 	const [nodeResult, neighborResult] = await Promise.all([
-		db.query<[MemoryNode[]]>('SELECT * FROM $id', { id: nodeId }),
+		db.query<[MemoryNode[]]>(
+			'SELECT * FROM <record<memory>>$id',
+			{ id: nodeId },
+		),
 		db.query<[MemoryNode[]]>(
 			`
       SELECT * FROM memory
       WHERE id INSIDE (
         SELECT ->relates_to[WHERE valid_until = NONE OR valid_until > time::now()]->memory.id
-        FROM $id
+        FROM <record<memory>>$id
       )
       LIMIT 10
     `,
@@ -150,7 +201,7 @@ export async function recall(
 	// FSRS tick — simplified next review interval
 	await db.query(
 		`
-    UPDATE $id SET
+    UPDATE <record<memory>>$id SET
       fsrs_next_review = time::now() + 1d,
       updated_at       = time::now()
   `,
@@ -171,9 +222,9 @@ export async function wander(
 	// If no anchor, pick a random high-salience active node
 	const anchorId = opts.anchor ?? await db.query<[{ id: string }[]]>(
 		`
-    SELECT id FROM memory
+    SELECT id, salience, (salience * rand()) AS _pick FROM memory
     WHERE ${ACTIVE_FILTER} AND ($scope = NONE OR scope = $scope)
-    ORDER BY salience * rand() DESC
+    ORDER BY _pick DESC
     LIMIT 1
   `,
 		{ scope: opts.scope ?? null },
@@ -203,20 +254,24 @@ export async function timeline(
 	opts: { scope?: string; from?: string; until?: string; limit?: number },
 ): Promise<MemoryNode[]> {
 	log.info('timeline()', opts)
+	const fromIso = opts.from ? new Date(opts.from).toISOString() : null
+	const untilIso = opts.until ? new Date(opts.until).toISOString() : null
+	const fromExpr = fromIso ? '<datetime>$from' : 'NONE'
+	const untilExpr = untilIso ? '<datetime>$until' : 'NONE'
 	return db.query<[MemoryNode[]]>(
 		`
     SELECT * FROM memory
     WHERE (valid_until = NONE OR valid_until > time::now())
       AND ($scope = NONE OR scope = $scope)
-      AND ($from  = NONE OR created_at >= <datetime>$from)
-      AND ($until = NONE OR created_at <= <datetime>$until)
+      AND (${fromExpr} = NONE OR created_at >= ${fromExpr})
+      AND (${untilExpr} = NONE OR created_at <= ${untilExpr})
     ORDER BY created_at DESC
     LIMIT $limit
   `,
 		{
 			scope: opts.scope ?? null,
-			from: opts.from ?? null,
-			until: opts.until ?? null,
+			...(fromIso ? { from: fromIso } : {}),
+			...(untilIso ? { until: untilIso } : {}),
 			limit: opts.limit ?? 50,
 		},
 	).then((r) => r[0] ?? [])

package/src/memory/write.ts

@@ -1,5 +1,7 @@
 import type { Surreal } from 'surrealdb'
 import { detectContradiction } from '../cognitive/contradiction.ts'
+import type { SuemoConfig } from '../config.ts'
+import { getEmbedding } from '../embedding/index.ts'
 import { getLogger } from '../logger.ts'
 import type { MemoryNode, ObserveInput } from '../types.ts'
 import { ObserveInputSchema } from '../types.ts'
@@ -10,25 +12,57 @@ const log = getLogger(['suemo', 'memory', 'write'])
 export async function observe(
 	db: Surreal,
 	rawInput: ObserveInput,
+	config: SuemoConfig,
 ): Promise<MemoryNode> {
 	const input = ObserveInputSchema.parse(rawInput)
 	log.info('observe()', { kind: input.kind, scope: input.scope, contentPreview: input.content.slice(0, 60) })
 
-	// 1. Get embedding — fn::embed() runs server-side
-	// We embed inside the CREATE query; the embedding field is set by UPSERT logic.
-	// We first check for a near-duplicate before inserting.
+	const { clause: embeddingClause, param: embeddingParam } = await getEmbedding(
+		input.content,
+		config.embedding,
+	)
+	log.debug('observe embedding resolved', {
+		provider: config.embedding.provider,
+		hasVectorParam: Boolean(embeddingParam),
+		dimension: embeddingParam?.length,
+	})
 
 	// 2. Dedup probe: ANN search for cosine similarity > 0.97
+	// For non-surreal providers, we pass the pre-computed vector as $qvec.
+	if (config.embedding.provider !== 'surreal' && !embeddingParam) {
+		throw new Error(`Missing embedding vector for provider: ${config.embedding.provider}`)
+	}
+
+	const dedupVecClause = config.embedding.provider === 'surreal'
+		? 'fn::embed($content)'
+		: '$qvec'
+	const dedupParams = config.embedding.provider === 'surreal'
+		? { content: input.content }
+		: { qvec: embeddingParam }
+	log.debug('observe dedup probe', {
+		provider: config.embedding.provider,
+		queryMode: config.embedding.provider === 'surreal' ? 'fn::embed($content)' : '$qvec',
+	})
+
 	const dedupResult = await db.query<[{ id: string; score: number }[]]>(
 		`
-    LET $vec = fn::embed($content);
-    SELECT id, vector::similarity::cosine(embedding, $vec) AS score
-    FROM memory
-    WHERE (valid_until = NONE OR valid_until > time::now())
-    ORDER BY embedding <|1, 20|> $vec
+    LET $vec = ${dedupVecClause};
+    LET $cand = (
+      SELECT id, embedding
+      FROM memory
+      WHERE (valid_until = NONE OR valid_until > time::now())
+        AND embedding <|1, 20|> $vec
+    );
+
+    SELECT id, score
+    FROM (
+      SELECT id, vector::similarity::cosine(embedding, $vec) AS score
+      FROM $cand
+    )
+    ORDER BY score DESC
     LIMIT 1
   `,
-		{ content: input.content },
+		dedupParams,
 	)
 
 	const topHit = dedupResult[0]?.[0]
@@ -39,8 +73,8 @@ export async function observe(
 		})
 		const updated = await db.query<[MemoryNode[]]>(
 			`
-      UPDATE $id SET
-        tags += $tags,
+      UPDATE <record<memory>>$id SET
+        tags += <set<string>>$tags,
         updated_at = time::now()
     `,
 			{ id: topHit.id, tags: input.tags },
@@ -48,16 +82,16 @@ export async function observe(
 		return updated[0]![0]!
 	}
 
-	// 3. Create new node with server-side embedding
+	// 3. Create new node with embedding
 	const created = await db.query<[MemoryNode[]]>(
 		`
     CREATE memory CONTENT {
       kind:       $kind,
       content:    $content,
       summary:    NONE,
-      tags:       $tags,
+      tags:       <set<string>>$tags,
       scope:      $scope,
-      embedding:  fn::embed($content),
+      embedding:  ${embeddingClause},
       confidence: $confidence,
       salience:   0.5,
       source:     $source,
@@ -72,9 +106,10 @@ export async function observe(
 			kind: input.kind,
 			content: input.content,
 			tags: input.tags,
-			scope: input.scope ?? null,
+			...(input.scope !== undefined ? { scope: input.scope } : {}),
 			confidence: input.confidence,
-			source: input.source ?? null,
+			...(input.source !== undefined ? { source: input.source } : {}),
+			...(embeddingParam ? { embedding: embeddingParam } : {}),
 		},
 	)
 
@@ -89,10 +124,11 @@ export async function observe(
 export async function believe(
 	db: Surreal,
 	input: Omit<ObserveInput, 'kind'>,
+	config: SuemoConfig,
 ): Promise<{ node: MemoryNode; contradicted?: MemoryNode }> {
 	log.info('believe()', { scope: input.scope })
 
-	const node = await observe(db, { ...input, kind: 'belief' })
+	const node = await observe(db, { ...input, kind: 'belief' }, config)
 
 	const contradicted = await detectContradiction(db, node)
 	if (contradicted) {
@@ -125,7 +161,7 @@ export async function invalidate(
 	log.info('invalidate()', { nodeId, reason })
 	await db.query(
 		`
-    UPDATE $id SET
+    UPDATE <record<memory>>$id SET
       valid_until = time::now(),
       updated_at  = time::now()
   `,

package/src/cli/commands/shared.ts

@@ -1,20 +0,0 @@
-import { Crust } from '@crustjs/core'
-
-// Root CLI — shared instance all commands are built off via .sub()
-// The two flags here are inherited by every subcommand.
-export const app = new Crust('suemo')
-	.meta({ description: 'Persistent semantic memory for AI agents — SurrealDB backend' })
-	.flags({
-		config: {
-			type: 'string',
-			short: 'c',
-			description: 'Path to suemo config file',
-			inherit: true,
-		},
-		debug: {
-			type: 'boolean',
-			short: 'd',
-			description: 'Enable verbose debug logging',
-			inherit: true,
-		},
-	})