cognova 0.2.26 → 0.2.28

package/server/api/memory/search.get.ts

@@ -1,5 +1,5 @@
-import { sql, desc, eq, and, gte, inArray } from 'drizzle-orm'
-import { getDb, schema } from '~~/server/db'
+import { sql } from 'drizzle-orm'
+import { getDb } from '~~/server/db'
 import { requireDb } from '~~/server/utils/db-guard'
 import type { MemoryChunk, MemoryChunkType } from '~~/shared/types'
 
@@ -12,48 +12,43 @@ export default defineEventHandler(async (event) => {
   const searchQuery = query.query as string | undefined
   const projectPath = query.projectPath as string | undefined
   const chunkType = query.chunkType as MemoryChunkType | undefined
-  const minRelevance = query.minRelevance ? parseFloat(query.minRelevance as string) : undefined
   const limit = Math.min(parseInt(query.limit as string) || 20, 100)
 
-  const conditions = []
+  // Build WHERE conditions
+  const conditions: ReturnType<typeof sql>[] = []
 
-  // Project filter
   if (projectPath)
-    conditions.push(eq(schema.memoryChunks.projectPath, projectPath))
+    conditions.push(sql`project_path = ${projectPath}`)
 
-  // Type filter
   if (chunkType)
-    conditions.push(eq(schema.memoryChunks.chunkType, chunkType))
+    conditions.push(sql`chunk_type = ${chunkType}`)
 
-  // Relevance filter
-  if (minRelevance !== undefined)
-    conditions.push(gte(schema.memoryChunks.relevanceScore, minRelevance))
+  if (searchQuery)
+    conditions.push(sql`search_vector @@ plainto_tsquery('english', ${searchQuery})`)
 
-  // Full-text search via tsvector + GIN index
-  if (searchQuery) {
-    const ftsResult = await db.execute<{ id: string }>(sql`
-      SELECT id FROM memory_chunks
-      WHERE search_vector @@ plainto_tsquery('english', ${searchQuery})
-      ORDER BY ts_rank(search_vector, plainto_tsquery('english', ${searchQuery})) DESC
-      LIMIT ${limit}
-    `)
-    const ids = ftsResult.map(r => r.id)
-    if (ids.length === 0) return { data: [] as MemoryChunk[] }
-    conditions.push(inArray(schema.memoryChunks.id, ids))
-  }
-
-  let dbQuery = db.select()
-    .from(schema.memoryChunks)
+  const whereClause = conditions.length > 0
+    ? sql`WHERE ${sql.join(conditions, sql` AND `)}`
+    : sql``
 
-  if (conditions.length > 0)
-    dbQuery = dbQuery.where(and(...conditions)) as typeof dbQuery
+  // Computed score: FTS rank (if searching) * access boost * recency decay
+  const scoreExpr = searchQuery
+    ? sql`
+        ts_rank(search_vector, plainto_tsquery('english', ${searchQuery}))
+        * (1.0 + LN(1 + access_count))
+        * (1.0 / (1.0 + EXTRACT(EPOCH FROM NOW() - COALESCE(last_accessed_at, created_at)) / 2592000))
+      `
+    : sql`
+        (1.0 + LN(1 + access_count))
+        * (1.0 / (1.0 + EXTRACT(EPOCH FROM NOW() - COALESCE(last_accessed_at, created_at)) / 2592000))
+      `
 
-  const memories = await dbQuery
-    .orderBy(
-      desc(schema.memoryChunks.relevanceScore),
-      desc(schema.memoryChunks.createdAt)
-    )
-    .limit(limit)
+  const memories = await db.execute<MemoryChunk>(sql`
+    SELECT *, ${scoreExpr} AS score
+    FROM memory_chunks
+    ${whereClause}
+    ORDER BY score DESC
+    LIMIT ${limit}
+  `)
 
   // Update access count and timestamp for retrieved memories
   if (memories.length > 0) {

package/server/api/memory/store.post.ts

@@ -21,8 +21,7 @@ export default defineEventHandler(async (event) => {
       projectPath: body.projectPath,
       chunkType: body.chunkType,
       content: body.content,
-      sourceExcerpt: body.sourceExcerpt,
-      relevanceScore: body.relevanceScore ?? 1.0
+      sourceExcerpt: body.sourceExcerpt
     })
     .returning()
 

package/server/bridge/responder.ts

@@ -1,6 +1,6 @@
 import { randomUUID } from 'crypto'
 import { query } from '@anthropic-ai/claude-agent-sdk'
-import { desc, eq } from 'drizzle-orm'
+import { eq, sql } from 'drizzle-orm'
 import { getDb, schema } from '~~/server/db'
 import { logTokenUsage } from '~~/server/utils/log-token-usage'
 import { sdkEnv } from '~~/server/utils/sdk-env'
@@ -44,10 +44,15 @@ async function getOrCreateMainChat() {
 async function loadMemoryContext(): Promise<string> {
   try {
     const db = getDb()
-    const memories = await db.select()
-      .from(schema.memoryChunks)
-      .orderBy(desc(schema.memoryChunks.relevanceScore), desc(schema.memoryChunks.createdAt))
-      .limit(10)
+    const memories = await db.execute<{ content: string }>(sql`
+      SELECT content,
+        (1.0 + LN(1 + access_count))
+        * (1.0 / (1.0 + EXTRACT(EPOCH FROM NOW() - COALESCE(last_accessed_at, created_at)) / 2592000))
+        AS score
+      FROM memory_chunks
+      ORDER BY score DESC
+      LIMIT 10
+    `)
 
     if (memories.length === 0) return ''
 

package/server/db/schema.ts

@@ -333,8 +333,7 @@ export const memoryChunks = pgTable('memory_chunks', {
   content: text('content').notNull(), // The extracted memory (concise)
   sourceExcerpt: text('source_excerpt'), // Original context (truncated for reference)
 
-  // Relevance & lifecycle (Mem0-inspired)
-  relevanceScore: real('relevance_score').default(1.0).notNull(), // 0-1, decays over time
+  // Usage tracking (relevance is computed at query time from access + recency)
   accessCount: integer('access_count').default(0).notNull(), // How often retrieved
   lastAccessedAt: timestamp('last_accessed_at', { withTimezone: true }),
 

package/server/drizzle/migrations/0017_unusual_landau.sql

@@ -0,0 +1 @@
+ALTER TABLE "memory_chunks" DROP COLUMN "relevance_score";