cognova 0.1.0

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

@@ -0,0 +1,83 @@
+import { desc, eq, sql } from 'drizzle-orm'
+import { getDb, schema } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+import type { MemoryChunk, MemoryContextResponse } from '~~/shared/types'
+
+export default defineEventHandler(async (event) => {
+  requireDb(event)
+
+  const query = getQuery(event)
+  const db = getDb()
+
+  const projectPath = query.project as string | undefined
+  const limit = Math.min(parseInt(query.limit as string) || 5, 20)
+
+  // Get recent, high-relevance memories for this project
+  let dbQuery = db.select()
+    .from(schema.memoryChunks)
+
+  if (projectPath)
+    dbQuery = dbQuery.where(eq(schema.memoryChunks.projectPath, projectPath)) as typeof dbQuery
+
+  const memories = await dbQuery
+    .orderBy(
+      desc(schema.memoryChunks.relevanceScore),
+      desc(schema.memoryChunks.createdAt)
+    )
+    .limit(limit)
+
+  // Update access count for retrieved memories
+  if (memories.length > 0) {
+    const ids = memories.map(m => m.id)
+    await db.execute(sql`
+      UPDATE memory_chunks
+      SET access_count = access_count + 1,
+          last_accessed_at = NOW()
+      WHERE id = ANY(${ids})
+    `)
+  }
+
+  // Format for Claude context injection
+  const formatted = formatForContext(memories as MemoryChunk[])
+
+  const response: MemoryContextResponse = {
+    memories: memories as MemoryChunk[],
+    formatted
+  }
+
+  return { data: response }
+})
+
+function formatForContext(memories: MemoryChunk[]): string {
+  if (memories.length === 0)
+    return ''
+
+  const lines = ['## Previous Context\n']
+
+  // Group by type
+  const byType = memories.reduce((acc, m) => {
+    if (!acc[m.chunkType])
+      acc[m.chunkType] = []
+    acc[m.chunkType]!.push(m)
+    return acc
+  }, {} as Record<string, MemoryChunk[]>)
+
+  const typeLabels: Record<string, string> = {
+    decision: 'Decisions',
+    fact: 'Key Facts',
+    solution: 'Solutions',
+    pattern: 'Patterns',
+    preference: 'Preferences',
+    summary: 'Summaries'
+  }
+
+  for (const [type, items] of Object.entries(byType)) {
+    const label = typeLabels[type] || type
+    lines.push(`### ${label}`)
+    for (const item of items)
+      lines.push(`- ${item.content}`)
+    lines.push('')
+  }
+
+  return lines.join('\n')
+}

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

@@ -0,0 +1,42 @@
+import { getDb, schema } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+import { extractMemories, extractMemoriesFromTranscriptFile } from '~~/server/services/memory-extractor'
+import type { ExtractMemoryInput, MemoryChunk } from '~~/shared/types'
+
+export default defineEventHandler(async (event) => {
+  requireDb(event)
+
+  const body = await readBody<ExtractMemoryInput & { transcriptPath?: string }>(event)
+  const db = getDb()
+
+  let memories: Awaited<ReturnType<typeof extractMemories>> = []
+
+  // Extract from transcript file path or raw transcript
+  if (body.transcriptPath)
+    memories = await extractMemoriesFromTranscriptFile(body.transcriptPath)
+  else if (body.transcript)
+    memories = await extractMemories(body.transcript)
+  else
+    throw createError({ statusCode: 400, message: 'Either transcript or transcriptPath is required' })
+
+  if (memories.length === 0)
+    return { data: [], message: 'No memories worth extracting' }
+
+  // Store extracted memories
+  const inserted = await db.insert(schema.memoryChunks)
+    .values(memories.map(m => ({
+      sessionId: body.sessionId,
+      projectPath: body.projectPath,
+      chunkType: m.type,
+      content: m.content,
+      relevanceScore: m.relevance
+    })))
+    .returning()
+
+  console.log(`[memory] Extracted and stored ${inserted.length} memories`)
+
+  return {
+    data: inserted as MemoryChunk[],
+    message: `Extracted ${inserted.length} memories`
+  }
+})

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

@@ -0,0 +1,70 @@
+import { sql, desc, eq, and, gte, ilike, or } from 'drizzle-orm'
+import { getDb, schema } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+import type { MemoryChunk, MemoryChunkType } from '~~/shared/types'
+
+export default defineEventHandler(async (event) => {
+  requireDb(event)
+
+  const query = getQuery(event)
+  const db = getDb()
+
+  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 = []
+
+  // Project filter
+  if (projectPath)
+    conditions.push(eq(schema.memoryChunks.projectPath, projectPath))
+
+  // Type filter
+  if (chunkType)
+    conditions.push(eq(schema.memoryChunks.chunkType, chunkType))
+
+  // Relevance filter
+  if (minRelevance !== undefined)
+    conditions.push(gte(schema.memoryChunks.relevanceScore, minRelevance))
+
+  // Text search (simple ILIKE for now, will upgrade to tsvector)
+  if (searchQuery) {
+    conditions.push(or(
+      ilike(schema.memoryChunks.content, `%${searchQuery}%`),
+      ilike(schema.memoryChunks.sourceExcerpt, `%${searchQuery}%`)
+    ))
+  }
+
+  let dbQuery = db.select()
+    .from(schema.memoryChunks)
+
+  if (conditions.length > 0)
+    dbQuery = dbQuery.where(and(...conditions)) as typeof dbQuery
+
+  const memories = await dbQuery
+    .orderBy(
+      desc(schema.memoryChunks.relevanceScore),
+      desc(schema.memoryChunks.createdAt)
+    )
+    .limit(limit)
+
+  // Update access count and timestamp for retrieved memories
+  if (memories.length > 0) {
+    try {
+      const ids = memories.map(m => m.id)
+      await db.execute(sql`
+        UPDATE memory_chunks
+        SET access_count = access_count + 1,
+            last_accessed_at = NOW()
+        WHERE id = ANY(ARRAY[${sql.join(ids.map(id => sql`${id}`), sql`, `)}]::uuid[])
+      `)
+    } catch (e) {
+      // Don't fail the request if access count update fails
+      console.error('[memory/search] Failed to update access count:', e)
+    }
+  }
+
+  return { data: memories as MemoryChunk[] }
+})

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

@@ -0,0 +1,31 @@
+import { getDb, schema } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+import type { CreateMemoryInput, MemoryChunk } from '~~/shared/types'
+
+export default defineEventHandler(async (event) => {
+  requireDb(event)
+
+  const body = await readBody<CreateMemoryInput>(event)
+  const db = getDb()
+
+  if (!body.content)
+    throw createError({ statusCode: 400, message: 'content is required' })
+
+  if (!body.chunkType)
+    throw createError({ statusCode: 400, message: 'chunkType is required' })
+
+  const [inserted] = await db.insert(schema.memoryChunks)
+    .values({
+      sessionId: body.sessionId,
+      projectPath: body.projectPath,
+      chunkType: body.chunkType,
+      content: body.content,
+      sourceExcerpt: body.sourceExcerpt,
+      relevanceScore: body.relevanceScore ?? 1.0
+    })
+    .returning()
+
+  console.log(`[memory] Stored memory: ${body.chunkType} - ${body.content.slice(0, 50)}...`)
+
+  return { data: inserted as MemoryChunk }
+})

package/server/api/projects/[id]/index.delete.ts

@@ -0,0 +1,40 @@
+import { eq } from 'drizzle-orm'
+import { getDb, schema } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+
+export default defineEventHandler(async (event) => {
+  requireDb(event)
+
+  const id = getRouterParam(event, 'id')
+
+  if (!id)
+    throw createError({ statusCode: 400, message: 'Project ID is required' })
+
+  const db = getDb()
+
+  // Check project exists
+  const [existing] = await db
+    .select({ id: schema.projects.id })
+    .from(schema.projects)
+    .where(eq(schema.projects.id, id))
+    .limit(1)
+
+  if (!existing)
+    throw createError({ statusCode: 404, message: 'Project not found' })
+
+  const userId = event.context.user?.id
+
+  // Soft delete
+  const [project] = await db
+    .update(schema.projects)
+    .set({
+      deletedAt: new Date(),
+      deletedBy: userId,
+      modifiedAt: new Date(),
+      modifiedBy: userId
+    })
+    .where(eq(schema.projects.id, id))
+    .returning()
+
+  return { data: project }
+})

package/server/api/projects/[id]/index.get.ts

@@ -0,0 +1,25 @@
+import { eq } from 'drizzle-orm'
+import { getDb, schema } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+
+export default defineEventHandler(async (event) => {
+  requireDb(event)
+
+  const id = getRouterParam(event, 'id')
+
+  if (!id)
+    throw createError({ statusCode: 400, message: 'Project ID is required' })
+
+  const db = getDb()
+
+  const [project] = await db
+    .select()
+    .from(schema.projects)
+    .where(eq(schema.projects.id, id))
+    .limit(1)
+
+  if (!project)
+    throw createError({ statusCode: 404, message: 'Project not found' })
+
+  return { data: project }
+})

package/server/api/projects/[id]/index.put.ts

@@ -0,0 +1,50 @@
+import { eq } from 'drizzle-orm'
+import { getDb, schema } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+import type { UpdateProjectInput } from '~~/shared/types'
+
+export default defineEventHandler(async (event) => {
+  requireDb(event)
+
+  const id = getRouterParam(event, 'id')
+
+  if (!id)
+    throw createError({ statusCode: 400, message: 'Project ID is required' })
+
+  const body = await readBody<UpdateProjectInput>(event)
+
+  // Validate color if provided
+  if (body.color && !/^#[0-9A-Fa-f]{6}$/.test(body.color))
+    throw createError({ statusCode: 400, message: 'Color must be a valid hex color (e.g., #3b82f6)' })
+
+  const db = getDb()
+
+  // Check project exists
+  const [existing] = await db
+    .select({ id: schema.projects.id })
+    .from(schema.projects)
+    .where(eq(schema.projects.id, id))
+    .limit(1)
+
+  if (!existing)
+    throw createError({ statusCode: 404, message: 'Project not found' })
+
+  const userId = event.context.user?.id
+
+  const updates: Record<string, unknown> = {
+    modifiedAt: new Date(),
+    modifiedBy: userId
+  }
+
+  if (body.name !== undefined) updates.name = body.name.trim()
+  if (body.color !== undefined) updates.color = body.color
+  if (body.description !== undefined) updates.description = body.description?.trim() || null
+
+  const [project] = await db
+    .update(schema.projects)
+    .set(updates)
+    .where(eq(schema.projects.id, id))
+    .returning()
+
+  return { data: project }
+})

package/server/api/projects/index.get.ts

@@ -0,0 +1,20 @@
+import { isNull } from 'drizzle-orm'
+import { getDb, schema } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+
+export default defineEventHandler(async (event) => {
+  requireDb(event)
+
+  const query = getQuery(event)
+  const includeDeleted = query.includeDeleted === 'true'
+
+  const db = getDb()
+
+  const projects = await db
+    .select()
+    .from(schema.projects)
+    .where(includeDeleted ? undefined : isNull(schema.projects.deletedAt))
+    .orderBy(schema.projects.name)
+
+  return { data: projects }
+})

package/server/api/projects/index.post.ts

@@ -0,0 +1,34 @@
+import { getDb, schema } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+import type { CreateProjectInput } from '~~/shared/types'
+
+export default defineEventHandler(async (event) => {
+  requireDb(event)
+
+  const body = await readBody<CreateProjectInput>(event)
+
+  if (!body.name?.trim())
+    throw createError({ statusCode: 400, message: 'Project name is required' })
+
+  if (!body.color?.trim())
+    throw createError({ statusCode: 400, message: 'Project color is required' })
+
+  // Validate hex color format
+  if (!/^#[0-9A-Fa-f]{6}$/.test(body.color))
+    throw createError({ statusCode: 400, message: 'Color must be a valid hex color (e.g., #3b82f6)' })
+
+  const db = getDb()
+  const userId = event.context.user?.id
+
+  const [project] = await db
+    .insert(schema.projects)
+    .values({
+      name: body.name.trim(),
+      color: body.color,
+      description: body.description?.trim() || null,
+      createdBy: userId
+    })
+    .returning()
+
+  return { data: project }
+})

package/server/api/secrets/[key].delete.ts

@@ -0,0 +1,31 @@
+import { getDb } from '~~/server/db'
+import { secrets } from '~~/server/db/schema'
+import { eq } from 'drizzle-orm'
+
+export default defineEventHandler(async (event) => {
+  const key = getRouterParam(event, 'key')
+
+  if (!key) {
+    throw createError({
+      statusCode: 400,
+      message: 'Key is required'
+    })
+  }
+
+  const db = getDb()
+
+  const existing = await db.query.secrets.findFirst({
+    where: (s, { eq }) => eq(s.key, key)
+  })
+
+  if (!existing) {
+    throw createError({
+      statusCode: 404,
+      message: `Secret with key "${key}" not found`
+    })
+  }
+
+  await db.delete(secrets).where(eq(secrets.key, key))
+
+  return { data: { deleted: true } }
+})

package/server/api/secrets/[key].get.ts

@@ -0,0 +1,30 @@
+import { getDb } from '~~/server/db'
+import { decryptSecret } from '~~/server/utils/crypto'
+
+export default defineEventHandler(async (event) => {
+  const key = getRouterParam(event, 'key')
+
+  if (!key) {
+    throw createError({
+      statusCode: 400,
+      message: 'Key is required'
+    })
+  }
+
+  const db = getDb()
+
+  const secret = await db.query.secrets.findFirst({
+    where: (s, { eq }) => eq(s.key, key)
+  })
+
+  if (!secret) {
+    throw createError({
+      statusCode: 404,
+      message: `Secret with key "${key}" not found`
+    })
+  }
+
+  const value = decryptSecret(secret.encryptedValue, secret.iv)
+
+  return { data: { key: secret.key, value } }
+})

package/server/api/secrets/[key].put.ts

@@ -0,0 +1,52 @@
+import { getDb } from '~~/server/db'
+import { secrets } from '~~/server/db/schema'
+import { encryptSecret } from '~~/server/utils/crypto'
+import { eq } from 'drizzle-orm'
+
+interface UpdateSecretInput {
+  value?: string
+  description?: string
+}
+
+export default defineEventHandler(async (event) => {
+  const key = getRouterParam(event, 'key')
+
+  if (!key)
+    throw createError({ statusCode: 400, message: 'Key is required' })
+
+  const body = await readBody<UpdateSecretInput>(event)
+  const db = getDb()
+
+  const existing = await db.query.secrets.findFirst({
+    where: (s, { eq }) => eq(s.key, key)
+  })
+
+  if (!existing)
+    throw createError({ statusCode: 404, message: `Secret with key "${key}" not found` })
+
+  const updateData: Record<string, unknown> = {
+    updatedAt: new Date()
+  }
+
+  if (body.value) {
+    const { encrypted, iv } = encryptSecret(body.value)
+    updateData.encryptedValue = encrypted
+    updateData.iv = iv
+  }
+
+  if (body.description !== undefined) {
+    updateData.description = body.description?.trim() || null
+  }
+
+  const [result] = await db.update(secrets)
+    .set(updateData)
+    .where(eq(secrets.key, key))
+    .returning({
+      id: secrets.id,
+      key: secrets.key,
+      description: secrets.description,
+      updatedAt: secrets.updatedAt
+    })
+
+  return { data: result }
+})

package/server/api/secrets/index.get.ts

@@ -0,0 +1,20 @@
+import { getDb } from '~~/server/db'
+import { secrets } from '~~/server/db/schema'
+import { desc } from 'drizzle-orm'
+
+export default defineEventHandler(async () => {
+  const db = getDb()
+
+  const results = await db.query.secrets.findMany({
+    columns: {
+      id: true,
+      key: true,
+      description: true,
+      createdAt: true,
+      updatedAt: true
+    },
+    orderBy: [desc(secrets.createdAt)]
+  })
+
+  return { data: results }
+})

package/server/api/secrets/index.post.ts

@@ -0,0 +1,58 @@
+import { getDb } from '~~/server/db'
+import { secrets } from '~~/server/db/schema'
+import { encryptSecret } from '~~/server/utils/crypto'
+
+interface CreateSecretInput {
+  key: string
+  value: string
+  description?: string
+}
+
+export default defineEventHandler(async (event) => {
+  const body = await readBody<CreateSecretInput>(event)
+
+  if (!body.key?.trim())
+    throw createError({ statusCode: 400, message: 'Key is required' })
+
+  if (!body.value)
+    throw createError({ statusCode: 400, message: 'Value is required' })
+
+  // Validate key format: SCREAMING_SNAKE_CASE
+  if (!/^[A-Z][A-Z0-9_]*$/.test(body.key))
+    throw createError({ statusCode: 400, message: 'Key must be SCREAMING_SNAKE_CASE (e.g., MY_API_KEY)' })
+
+  if (body.key.length > 255)
+    throw createError({ statusCode: 400, message: 'Key must be 255 characters or less' })
+
+  const db = getDb()
+  const userId = event.context.user?.id
+
+  // Check for duplicate key
+  const existing = await db.query.secrets.findFirst({
+    where: (s, { eq }) => eq(s.key, body.key)
+  })
+
+  if (existing) {
+    throw createError({
+      statusCode: 409,
+      message: `Secret with key "${body.key}" already exists`
+    })
+  }
+
+  const { encrypted, iv } = encryptSecret(body.value)
+
+  const [result] = await db.insert(secrets).values({
+    key: body.key,
+    encryptedValue: encrypted,
+    iv,
+    description: body.description?.trim() || null,
+    createdBy: userId
+  }).returning({
+    id: secrets.id,
+    key: secrets.key,
+    description: secrets.description,
+    createdAt: secrets.createdAt
+  })
+
+  return { data: result }
+})

package/server/api/tasks/[id]/index.delete.ts

@@ -0,0 +1,46 @@
+import { eq } from 'drizzle-orm'
+import { getDb, schema } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+
+export default defineEventHandler(async (event) => {
+  requireDb(event)
+
+  const id = getRouterParam(event, 'id')
+
+  if (!id)
+    throw createError({ statusCode: 400, message: 'Task ID is required' })
+
+  const db = getDb()
+
+  // Check task exists
+  const [existing] = await db
+    .select({ id: schema.tasks.id })
+    .from(schema.tasks)
+    .where(eq(schema.tasks.id, id))
+    .limit(1)
+
+  if (!existing)
+    throw createError({ statusCode: 404, message: 'Task not found' })
+
+  const userId = event.context.user?.id
+
+  // Soft delete
+  await db
+    .update(schema.tasks)
+    .set({
+      deletedAt: new Date(),
+      deletedBy: userId,
+      modifiedAt: new Date(),
+      modifiedBy: userId
+    })
+    .where(eq(schema.tasks.id, id))
+
+  // Fetch updated task with project relation
+  const [task] = await db.query.tasks.findMany({
+    where: (tasks, { eq }) => eq(tasks.id, id),
+    with: { project: true },
+    limit: 1
+  })
+
+  return { data: task }
+})

package/server/api/tasks/[id]/index.get.ts

@@ -0,0 +1,24 @@
+import { getDb } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+
+export default defineEventHandler(async (event) => {
+  requireDb(event)
+
+  const id = getRouterParam(event, 'id')
+
+  if (!id)
+    throw createError({ statusCode: 400, message: 'Task ID is required' })
+
+  const db = getDb()
+
+  const [task] = await db.query.tasks.findMany({
+    where: (tasks, { eq }) => eq(tasks.id, id),
+    with: { project: true, creator: true },
+    limit: 1
+  })
+
+  if (!task)
+    throw createError({ statusCode: 404, message: 'Task not found' })
+
+  return { data: task }
+})