cognova 0.1.0

package/server/api/fs/list.get.ts

@@ -0,0 +1,99 @@
+import { readdir, stat } from 'fs/promises'
+import { join } from 'path'
+import type { FileEntry } from '~/../../shared/types'
+
+export default defineEventHandler(async (event) => {
+  const query = getQuery(event)
+  const requestedPath = (query.path as string) || '/'
+  const recursive = query.recursive === 'true'
+
+  const absolutePath = validatePath(requestedPath)
+
+  try {
+    const entries = await readdir(absolutePath, { withFileTypes: true })
+    const result: FileEntry[] = []
+
+    for (const entry of entries) {
+      // Skip hidden files/folders (starting with .)
+      if (entry.name.startsWith('.')) continue
+
+      const entryPath = join(absolutePath, entry.name)
+      const stats = await stat(entryPath)
+
+      const fileEntry: FileEntry = {
+        name: entry.name,
+        path: toRelativePath(entryPath),
+        type: entry.isDirectory() ? 'directory' : 'file',
+        modifiedAt: stats.mtime
+      }
+
+      if (entry.isFile()) {
+        fileEntry.size = stats.size
+      }
+
+      if (entry.isDirectory() && recursive) {
+        // Recursively get children
+        const children = await getDirectoryContents(entryPath)
+        fileEntry.children = children
+      }
+
+      result.push(fileEntry)
+    }
+
+    // Sort: directories first, then alphabetically
+    result.sort((a, b) => {
+      if (a.type !== b.type) return a.type === 'directory' ? -1 : 1
+      return a.name.localeCompare(b.name)
+    })
+
+    return { data: result }
+  } catch (error: unknown) {
+    const err = error as NodeJS.ErrnoException
+    if (err.code === 'ENOENT') {
+      throw createError({
+        statusCode: 404,
+        message: 'Directory not found'
+      })
+    }
+    throw createError({
+      statusCode: 500,
+      message: 'Failed to list directory'
+    })
+  }
+})
+
+async function getDirectoryContents(dirPath: string): Promise<FileEntry[]> {
+  const entries = await readdir(dirPath, { withFileTypes: true })
+  const result: FileEntry[] = []
+
+  for (const entry of entries) {
+    if (entry.name.startsWith('.')) continue
+
+    const entryPath = join(dirPath, entry.name)
+    const stats = await stat(entryPath)
+
+    const fileEntry: FileEntry = {
+      name: entry.name,
+      path: toRelativePath(entryPath),
+      type: entry.isDirectory() ? 'directory' : 'file',
+      modifiedAt: stats.mtime
+    }
+
+    if (entry.isFile()) {
+      fileEntry.size = stats.size
+    }
+
+    if (entry.isDirectory()) {
+      fileEntry.children = await getDirectoryContents(entryPath)
+    }
+
+    result.push(fileEntry)
+  }
+
+  result.sort((a, b) => {
+    if (a.type !== b.type) return a.type === 'directory' ? -1 : 1
+    return a.name.localeCompare(b.name)
+  })
+
+  return result
+}

package/server/api/fs/mkdir.post.ts

@@ -0,0 +1,44 @@
+import { mkdir, stat } from 'fs/promises'
+
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event)
+  const requestedPath = body.path
+
+  if (!requestedPath) {
+    throw createError({
+      statusCode: 400,
+      message: 'Path is required'
+    })
+  }
+
+  const absolutePath = validatePath(requestedPath)
+
+  // Check if path already exists
+  try {
+    await stat(absolutePath)
+    throw createError({
+      statusCode: 409,
+      message: 'Path already exists'
+    })
+  } catch (error: unknown) {
+    const err = error as NodeJS.ErrnoException & { statusCode?: number }
+    if (err.statusCode === 409) throw error
+    // ENOENT is expected - path doesn't exist yet
+  }
+
+  try {
+    await mkdir(absolutePath, { recursive: true })
+
+    return {
+      data: {
+        path: requestedPath,
+        created: true
+      }
+    }
+  } catch {
+    throw createError({
+      statusCode: 500,
+      message: 'Failed to create directory'
+    })
+  }
+})

package/server/api/fs/move.post.ts

@@ -0,0 +1,68 @@
+import { rename, stat } from 'fs/promises'
+import { join, basename } from 'path'
+
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event)
+  const { sourcePath, destinationPath } = body
+
+  if (!sourcePath || !destinationPath) {
+    throw createError({
+      statusCode: 400,
+      message: 'sourcePath and destinationPath are required'
+    })
+  }
+
+  const absoluteSource = validatePath(sourcePath)
+  const absoluteDestination = validatePath(destinationPath)
+
+  // Check if source exists
+  try {
+    await stat(absoluteSource)
+  } catch {
+    throw createError({
+      statusCode: 404,
+      message: 'Source path not found'
+    })
+  }
+
+  // Check if destination is a directory
+  let targetPath: string
+  try {
+    const destStats = await stat(absoluteDestination)
+    if (destStats.isDirectory()) {
+      // Moving into a directory - append the source filename
+      targetPath = join(absoluteDestination, basename(absoluteSource))
+    } else {
+      throw createError({
+        statusCode: 400,
+        message: 'Destination must be a directory'
+      })
+    }
+  } catch (error: unknown) {
+    const err = error as NodeJS.ErrnoException
+    if (err.code === 'ENOENT') {
+      throw createError({
+        statusCode: 404,
+        message: 'Destination directory not found'
+      })
+    }
+    throw error
+  }
+
+  try {
+    await rename(absoluteSource, targetPath)
+
+    return {
+      data: {
+        oldPath: sourcePath,
+        newPath: toRelativePath(targetPath),
+        moved: true
+      }
+    }
+  } catch {
+    throw createError({
+      statusCode: 500,
+      message: 'Failed to move file'
+    })
+  }
+})

package/server/api/fs/read.post.ts

@@ -0,0 +1,48 @@
+import { readFile, stat } from 'fs/promises'
+
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event)
+  const requestedPath = body.path
+
+  if (!requestedPath) {
+    throw createError({
+      statusCode: 400,
+      message: 'Path is required'
+    })
+  }
+
+  const absolutePath = validatePath(requestedPath)
+
+  try {
+    const [content, stats] = await Promise.all([
+      readFile(absolutePath, 'utf-8'),
+      stat(absolutePath)
+    ])
+
+    return {
+      data: {
+        path: requestedPath,
+        content,
+        modifiedAt: stats.mtime
+      }
+    }
+  } catch (error: unknown) {
+    const err = error as NodeJS.ErrnoException
+    if (err.code === 'ENOENT') {
+      throw createError({
+        statusCode: 404,
+        message: 'File not found'
+      })
+    }
+    if (err.code === 'EISDIR') {
+      throw createError({
+        statusCode: 400,
+        message: 'Path is a directory, not a file'
+      })
+    }
+    throw createError({
+      statusCode: 500,
+      message: 'Failed to read file'
+    })
+  }
+})

package/server/api/fs/rename.post.ts

@@ -0,0 +1,55 @@
+import { rename, stat } from 'fs/promises'
+
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event)
+  const { oldPath, newPath } = body
+
+  if (!oldPath || !newPath) {
+    throw createError({
+      statusCode: 400,
+      message: 'Both oldPath and newPath are required'
+    })
+  }
+
+  const absoluteOldPath = validatePath(oldPath)
+  const absoluteNewPath = validatePath(newPath)
+
+  // Check if source exists
+  try {
+    await stat(absoluteOldPath)
+  } catch {
+    throw createError({
+      statusCode: 404,
+      message: 'Source path not found'
+    })
+  }
+
+  // Check if destination already exists
+  try {
+    await stat(absoluteNewPath)
+    throw createError({
+      statusCode: 409,
+      message: 'Destination path already exists'
+    })
+  } catch (error: unknown) {
+    const err = error as { statusCode?: number }
+    if (err.statusCode === 409) throw error
+    // ENOENT is expected - destination doesn't exist
+  }
+
+  try {
+    await rename(absoluteOldPath, absoluteNewPath)
+
+    return {
+      data: {
+        oldPath,
+        newPath
+      }
+    }
+  } catch {
+    throw createError({
+      statusCode: 500,
+      message: 'Failed to rename/move'
+    })
+  }
+})

package/server/api/fs/write.post.ts

@@ -0,0 +1,51 @@
+import { writeFile, stat, mkdir } from 'fs/promises'
+import { dirname } from 'path'
+
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event)
+  const { path: requestedPath, content } = body
+
+  if (!requestedPath) {
+    throw createError({
+      statusCode: 400,
+      message: 'Path is required'
+    })
+  }
+
+  if (content === undefined) {
+    throw createError({
+      statusCode: 400,
+      message: 'Content is required'
+    })
+  }
+
+  const absolutePath = validatePath(requestedPath)
+
+  // Check if file exists
+  let created = false
+  try {
+    await stat(absolutePath)
+  } catch {
+    created = true
+  }
+
+  try {
+    // Ensure parent directory exists
+    await mkdir(dirname(absolutePath), { recursive: true })
+
+    // Write the file
+    await writeFile(absolutePath, content, 'utf-8')
+
+    return {
+      data: {
+        path: requestedPath,
+        created
+      }
+    }
+  } catch {
+    throw createError({
+      statusCode: 500,
+      message: 'Failed to write file'
+    })
+  }
+})

package/server/api/health.get.ts

@@ -0,0 +1,40 @@
+import { sql } from 'drizzle-orm'
+import { getDbState, isDbAvailable } from '~~/server/utils/db-state'
+import { getDb } from '~~/server/db'
+
+function getDeploymentType(url: string): 'local' | 'remote' | null {
+  if (!url) return null
+  const isLocal = url.includes('localhost') || url.includes('127.0.0.1') || url.includes('db:5432')
+  return isLocal ? 'local' : 'remote'
+}
+
+export default defineEventHandler(async (event) => {
+  const config = useRuntimeConfig(event)
+  const dbState = getDbState()
+
+  let dbLatency: number | null = null
+  let dbError: string | null = null
+
+  if (isDbAvailable()) {
+    try {
+      const start = Date.now()
+      const db = getDb()
+      await db.execute(sql`SELECT 1`)
+      dbLatency = Date.now() - start
+    } catch (e) {
+      dbError = e instanceof Error ? e.message : 'Unknown error'
+    }
+  }
+
+  return {
+    status: 'ok',
+    timestamp: new Date().toISOString(),
+    database: {
+      configured: !!config.databaseUrl,
+      deployment: getDeploymentType(config.databaseUrl),
+      available: dbState.available,
+      latency: dbLatency,
+      error: dbError || dbState.error || null
+    }
+  }
+})

package/server/api/home.get.ts

@@ -0,0 +1,26 @@
+import { readFile } from 'fs/promises'
+import { join } from 'path'
+import { getVaultRoot } from '~~/server/utils/path-validator'
+
+export default defineEventHandler(async () => {
+  const vaultRoot = getVaultRoot()
+  const indexPath = join(vaultRoot, 'index.md')
+
+  try {
+    const content = await readFile(indexPath, 'utf-8')
+    return {
+      data: {
+        hasCustomHome: true,
+        content
+      }
+    }
+  } catch {
+    // index.md doesn't exist, return default
+    return {
+      data: {
+        hasCustomHome: false,
+        content: null
+      }
+    }
+  }
+})

package/server/api/hooks/events/index.get.ts

@@ -0,0 +1,56 @@
+import { eq, gte, inArray, and, desc } from 'drizzle-orm'
+import { getDb, schema } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+import type { HookEventFilters, HookEventType } from '~~/shared/types'
+
+export default defineEventHandler(async (event) => {
+  requireDb(event)
+
+  const query = getQuery(event) as HookEventFilters
+  const limit = Math.min(Number(query.limit) || 100, 500)
+
+  const db = getDb()
+  const conditions = []
+
+  // Event type filter
+  if (query.eventType) {
+    const types = Array.isArray(query.eventType) ? query.eventType : [query.eventType]
+    conditions.push(inArray(schema.hookEvents.eventType, types as HookEventType[]))
+  }
+
+  // Session filter
+  if (query.sessionId)
+    conditions.push(eq(schema.hookEvents.sessionId, query.sessionId))
+
+  // Tool filter
+  if (query.toolName)
+    conditions.push(eq(schema.hookEvents.toolName, query.toolName))
+
+  // Blocked filter
+  if (query.blocked !== undefined) {
+    const blocked = query.blocked === true || query.blocked === 'true'
+    conditions.push(eq(schema.hookEvents.blocked, blocked))
+  }
+
+  // Since filter
+  if (query.since)
+    conditions.push(gte(schema.hookEvents.createdAt, new Date(query.since)))
+
+  let dbQuery = db.select()
+    .from(schema.hookEvents)
+
+  if (conditions.length > 0)
+    dbQuery = dbQuery.where(and(...conditions)) as typeof dbQuery
+
+  const events = await dbQuery
+    .orderBy(desc(schema.hookEvents.createdAt))
+    .limit(limit)
+
+  // Parse eventData JSON
+  const parsedEvents = events.map(e => ({
+    ...e,
+    eventData: e.eventData ? JSON.parse(e.eventData) : undefined
+  }))
+
+  return { data: parsedEvents }
+})

package/server/api/hooks/events/index.post.ts

@@ -0,0 +1,36 @@
+import { getDb, schema } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+import type { CreateHookEventInput } from '~~/shared/types'
+
+export default defineEventHandler(async (event) => {
+  requireDb(event)
+
+  const body = await readBody<CreateHookEventInput>(event)
+
+  if (!body.eventType)
+    throw createError({ statusCode: 400, message: 'eventType is required' })
+
+  const db = getDb()
+
+  const [hookEvent] = await db
+    .insert(schema.hookEvents)
+    .values({
+      eventType: body.eventType,
+      sessionId: body.sessionId || null,
+      projectDir: body.projectDir || null,
+      toolName: body.toolName || null,
+      toolMatcher: body.toolMatcher || null,
+      eventData: body.eventData ? JSON.stringify(body.eventData) : null,
+      exitCode: body.exitCode ?? null,
+      blocked: body.blocked ?? false,
+      blockReason: body.blockReason || null,
+      durationMs: body.durationMs ?? null,
+      hookScript: body.hookScript || null
+    })
+    .returning()
+
+  if (!hookEvent)
+    throw createError({ statusCode: 500, message: 'Failed to create hook event' })
+
+  return { data: hookEvent }
+})

package/server/api/hooks/stats.get.ts

@@ -0,0 +1,99 @@
+import { gte } from 'drizzle-orm'
+import { getDb, schema } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+import type { StatsPeriod, HookEventStats, HookDailyData, HookToolBreakdown, HookEventType } from '~~/shared/types'
+
+function getPeriodInterval(period: StatsPeriod): Date {
+  const now = new Date()
+  switch (period) {
+    case '24h':
+      return new Date(now.getTime() - 24 * 60 * 60 * 1000)
+    case '7d':
+      return new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000)
+    case '30d':
+      return new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000)
+  }
+}
+
+export default defineEventHandler(async (event) => {
+  requireDb(event)
+
+  const query = getQuery(event)
+  const period = (query.period as StatsPeriod) || '7d'
+  const periodStart = getPeriodInterval(period)
+
+  const db = getDb()
+
+  // Get all events in period
+  const events = await db.select()
+    .from(schema.hookEvents)
+    .where(gte(schema.hookEvents.createdAt, periodStart))
+
+  const totalEvents = events.length
+  const blockedEvents = events.filter(e => e.blocked).length
+  const blockRate = totalEvents > 0 ? Math.round((blockedEvents / totalEvents) * 100) : 0
+
+  // Average duration
+  const withDuration = events.filter(e => e.durationMs !== null)
+  const avgDurationMs = withDuration.length > 0
+    ? Math.round(withDuration.reduce((sum, e) => sum + (e.durationMs || 0), 0) / withDuration.length)
+    : 0
+
+  // Events by type
+  const eventsByType: Partial<Record<HookEventType, number>> = {}
+  for (const e of events)
+    eventsByType[e.eventType as HookEventType] = (eventsByType[e.eventType as HookEventType] || 0) + 1
+
+  // Tool breakdown
+  const toolMap = new Map<string, { total: number, blocked: number, totalDuration: number, count: number }>()
+  for (const e of events) {
+    if (!e.toolName) continue
+    const existing = toolMap.get(e.toolName) || { total: 0, blocked: 0, totalDuration: 0, count: 0 }
+    existing.total++
+    if (e.blocked) existing.blocked++
+    if (e.durationMs) {
+      existing.totalDuration += e.durationMs
+      existing.count++
+    }
+    toolMap.set(e.toolName, existing)
+  }
+
+  const toolBreakdown: HookToolBreakdown[] = Array.from(toolMap.entries())
+    .map(([toolName, data]) => ({
+      toolName,
+      total: data.total,
+      blocked: data.blocked,
+      avgDurationMs: data.count > 0 ? Math.round(data.totalDuration / data.count) : 0
+    }))
+    .sort((a, b) => b.total - a.total)
+
+  // Daily activity
+  const dailyMap = new Map<string, HookDailyData>()
+  for (const e of events) {
+    const date = e.createdAt.toISOString().split('T')[0]!
+    const existing = dailyMap.get(date) || { date, total: 0, blocked: 0, allowed: 0, avgDurationMs: 0 }
+    existing.total++
+    if (e.blocked) existing.blocked++
+    else existing.allowed++
+    dailyMap.set(date, existing)
+  }
+
+  const dailyActivity = Array.from(dailyMap.values()).sort((a, b) => a.date.localeCompare(b.date))
+
+  // Recent sessions (unique, last 10)
+  const recentSessions = [...new Set(events.filter(e => e.sessionId).map(e => e.sessionId!))]
+    .slice(0, 10)
+
+  const stats: HookEventStats = {
+    totalEvents,
+    blockedEvents,
+    blockRate,
+    avgDurationMs,
+    eventsByType,
+    toolBreakdown,
+    dailyActivity,
+    recentSessions
+  }
+
+  return { data: stats }
+})

package/server/api/memory/[id].delete.ts

@@ -0,0 +1,26 @@
+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: 'Memory ID required' })
+
+  const db = getDb()
+
+  // Verify memory exists
+  const existing = await db.select({ id: schema.memoryChunks.id })
+    .from(schema.memoryChunks)
+    .where(eq(schema.memoryChunks.id, id))
+    .limit(1)
+
+  if (existing.length === 0)
+    throw createError({ statusCode: 404, message: 'Memory not found' })
+
+  await db.delete(schema.memoryChunks).where(eq(schema.memoryChunks.id, id))
+
+  return { data: { success: true } }
+})