cognova 0.1.0

package/drizzle.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'drizzle-kit'
+
+export default defineConfig({
+  schema: './server/db/schema.ts',
+  out: './server/drizzle/migrations',
+  dialect: 'postgresql',
+  dbCredentials: {
+    url: process.env.DATABASE_URL!
+  }
+})

package/nuxt.config.ts

@@ -0,0 +1,98 @@
+// https://nuxt.com/docs/api/configuration/nuxt-config
+export default defineNuxtConfig({
+  modules: [
+    '@nuxt/eslint',
+    '@nuxt/ui',
+    '@nuxtjs/mdc'
+  ],
+
+  devtools: {
+    enabled: true
+  },
+
+  css: ['~/assets/css/main.css'],
+
+  mdc: {
+    highlight: {
+      theme: {
+        default: 'github-light',
+        dark: 'github-dark'
+      },
+      langs: [
+        'typescript',
+        'javascript',
+        'ts',
+        'js',
+        'bash',
+        'shell',
+        'vue',
+        'html',
+        'css',
+        'scss',
+        'json',
+        'yaml',
+        'toml',
+        'xml',
+        'markdown',
+        'md',
+        'sql',
+        'graphql',
+        'python',
+        'go',
+        'rust',
+        'c',
+        'cpp',
+        'cs',
+        'java',
+        'dockerfile',
+        'diff',
+        'kotlin'
+      ]
+    }
+  },
+
+  runtimeConfig: {
+    databaseUrl: process.env.DATABASE_URL || ''
+  },
+
+  alias: {
+    '@shared': '~/../../shared'
+  },
+
+  routeRules: {},
+
+  compatibilityDate: '2025-01-15',
+
+  // Enable WebSocket support for terminal
+  nitro: {
+    experimental: {
+      websocket: true
+    },
+    // node-pty is a native module that can't be bundled
+    externals: {
+      external: ['node-pty']
+    }
+  },
+
+  // Required for UEditor to avoid prosemirror plugin conflicts
+  vite: {
+    optimizeDeps: {
+      include: [
+        '@nuxt/ui > prosemirror-state',
+        '@nuxt/ui > prosemirror-transform',
+        '@nuxt/ui > prosemirror-model',
+        '@nuxt/ui > prosemirror-view',
+        '@nuxt/ui > prosemirror-gapcursor'
+      ]
+    }
+  },
+
+  eslint: {
+    config: {
+      stylistic: {
+        commaDangle: 'never',
+        braceStyle: '1tbs'
+      }
+    }
+  }
+})

package/package.json

@@ -0,0 +1,107 @@
+{
+  "name": "cognova",
+  "type": "module",
+  "version": "0.1.0",
+  "description": "Personal knowledge management system with Claude Code integration",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Patrity/cognova.git"
+  },
+  "bin": {
+    "cognova": "./dist/cli/index.js"
+  },
+  "files": [
+    "dist/cli",
+    "app",
+    "shared",
+    "server",
+    "Claude",
+    "nuxt.config.ts",
+    "tsconfig.json",
+    "drizzle.config.ts",
+    ".env.example"
+  ],
+  "scripts": {
+    "cli:build": "pnpm --filter cognova-cli build",
+    "cli:dev": "pnpm --filter cognova-cli dev",
+    "build": "nuxt build",
+    "dev": "nuxt dev",
+    "preview": "nuxt preview",
+    "prepare": "nuxt prepare",
+    "lint": "eslint .",
+    "typecheck": "nuxt typecheck",
+    "db:generate": "drizzle-kit generate",
+    "db:migrate": "drizzle-kit migrate",
+    "db:push": "drizzle-kit push",
+    "db:studio": "drizzle-kit studio",
+    "db:up": "docker compose --profile local up -d db",
+    "db:down": "docker compose --profile local down",
+    "docker:up": "./scripts/docker-up.sh -d",
+    "docker:down": "docker compose --profile local down",
+    "auth:create-admin": "tsx scripts/create-admin.ts",
+    "auth:reset-pw": "tsx scripts/reset-password.ts"
+  },
+  "dependencies": {
+    "@anthropic-ai/claude-agent-sdk": "^0.2.23",
+    "@anthropic-ai/sdk": "^0.72.1",
+    "@codemirror/lang-cpp": "^6.0.3",
+    "@codemirror/lang-css": "^6.3.1",
+    "@codemirror/lang-html": "^6.4.11",
+    "@codemirror/lang-java": "^6.0.2",
+    "@codemirror/lang-javascript": "^6.2.4",
+    "@codemirror/lang-json": "^6.0.2",
+    "@codemirror/lang-markdown": "^6.5.0",
+    "@codemirror/lang-python": "^6.2.1",
+    "@codemirror/lang-rust": "^6.0.2",
+    "@codemirror/lang-sql": "^6.10.0",
+    "@codemirror/lang-vue": "^0.1.3",
+    "@codemirror/lang-xml": "^6.1.0",
+    "@codemirror/lang-yaml": "^6.1.2",
+    "@codemirror/language": "^6.12.1",
+    "@codemirror/legacy-modes": "^6.5.2",
+    "@codemirror/state": "^6.5.4",
+    "@codemirror/theme-one-dark": "^6.1.3",
+    "@codemirror/view": "^6.39.11",
+    "@iconify-json/lucide": "^1.2.82",
+    "@iconify-json/simple-icons": "^1.2.63",
+    "@nuxt/ui": "^4.3.0",
+    "@nuxtjs/mdc": "^0.20.0",
+    "@unovis/ts": "^1.6.2",
+    "@unovis/vue": "^1.6.2",
+    "@vueuse/core": "^14.1.0",
+    "@vueuse/integrations": "^14.1.0",
+    "@xterm/addon-fit": "^0.11.0",
+    "@xterm/addon-web-links": "^0.12.0",
+    "@xterm/xterm": "^6.0.0",
+    "better-auth": "^1.4.17",
+    "chokidar": "^5.0.0",
+    "codemirror": "^6.0.2",
+    "cron": "^4.4.0",
+    "date-fns": "^4.1.0",
+    "dotenv": "^17.2.3",
+    "drizzle-orm": "^0.45.1",
+    "gray-matter": "^4.0.3",
+    "node-pty": "^1.1.0",
+    "nuxt": "^4.2.2",
+    "postgres": "^3.4.8",
+    "shiki": "^3.21.0",
+    "sortablejs": "^1.15.6",
+    "tailwindcss": "^4.0.0"
+  },
+  "devDependencies": {
+    "@nuxt/eslint": "^1.12.1",
+    "@types/node": "^25.0.8",
+    "@types/sortablejs": "^1.15.9",
+    "drizzle-kit": "^0.31.8",
+    "eslint": "^9.39.2",
+    "tsx": "^4.21.0",
+    "typescript": "^5.9.3",
+    "vue-tsc": "^3.2.1"
+  },
+  "packageManager": "pnpm@10.26.1",
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "node-pty"
+    ]
+  }
+}

package/server/api/agents/[id]/cancel.post.ts

@@ -0,0 +1,27 @@
+import { agentRegistry } from '~~/server/utils/agent-registry'
+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: 'Agent ID is required' })
+  }
+
+  // Cancel all running executions for this agent
+  const cancelledCount = agentRegistry.cancelByAgentId(id)
+
+  if (cancelledCount === 0) {
+    throw createError({
+      statusCode: 404,
+      message: 'No running executions found for this agent'
+    })
+  }
+
+  return {
+    success: true,
+    message: `Cancelled ${cancelledCount} running execution(s)`,
+    cancelledCount
+  }
+})

package/server/api/agents/[id]/run.post.ts

@@ -0,0 +1,34 @@
+import { eq } from 'drizzle-orm'
+import { getDb, schema } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+import { executeAgent } from '~~/server/services/agent-executor'
+
+export default defineEventHandler(async (event) => {
+  requireDb(event)
+
+  const id = getRouterParam(event, 'id')
+  if (!id) {
+    throw createError({ statusCode: 400, message: 'Agent ID is required' })
+  }
+
+  const db = getDb()
+
+  const agent = await db.query.cronAgents.findFirst({
+    where: eq(schema.cronAgents.id, id)
+  })
+
+  if (!agent) {
+    throw createError({ statusCode: 404, message: 'Agent not found' })
+  }
+
+  // Execute asynchronously (don't wait for completion)
+  executeAgent({
+    id: agent.id,
+    name: agent.name,
+    prompt: agent.prompt,
+    maxTurns: agent.maxTurns ?? 50,
+    maxBudgetUsd: agent.maxBudgetUsd ?? undefined
+  }).catch(err => console.error(`[agent] Manual run failed for ${agent.name}:`, err))
+
+  return { message: 'Agent started' }
+})

package/server/api/agents/[id]/runs.get.ts

@@ -0,0 +1,45 @@
+import { eq, desc, and, gte } from 'drizzle-orm'
+import { getDb, schema } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+import type { StatsPeriod } 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 id = getRouterParam(event, 'id')
+  if (!id) {
+    throw createError({ statusCode: 400, message: 'Agent ID is required' })
+  }
+
+  const query = getQuery(event)
+  const limit = parseInt(query.limit as string) || 100
+  const period = query.period as StatsPeriod | undefined
+
+  const db = getDb()
+
+  // Build where clause
+  const whereConditions = [eq(schema.cronAgentRuns.agentId, id)]
+  if (period) {
+    whereConditions.push(gte(schema.cronAgentRuns.startedAt, getPeriodInterval(period)))
+  }
+
+  const runs = await db.query.cronAgentRuns.findMany({
+    where: and(...whereConditions),
+    orderBy: [desc(schema.cronAgentRuns.startedAt)],
+    limit
+  })
+
+  return { data: runs }
+})

package/server/api/agents/[id]/stats.get.ts

@@ -0,0 +1,94 @@
+import { eq, and, gte } from 'drizzle-orm'
+import { getDb, schema } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+import type { StatsPeriod, AgentDetailStats, DailyRunData } 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 id = getRouterParam(event, 'id')
+  if (!id) {
+    throw createError({ statusCode: 400, message: 'Agent ID is required' })
+  }
+
+  const query = getQuery(event)
+  const period = (query.period as StatsPeriod) || '7d'
+  const periodStart = getPeriodInterval(period)
+
+  const db = getDb()
+
+  // Get all runs for this agent in period
+  const runs = await db.query.cronAgentRuns.findMany({
+    where: and(
+      eq(schema.cronAgentRuns.agentId, id),
+      gte(schema.cronAgentRuns.startedAt, periodStart)
+    )
+  })
+
+  const totalRuns = runs.length
+  const successfulRuns = runs.filter(r => r.status === 'success').length
+  const successRate = totalRuns > 0 ? Math.round((successfulRuns / totalRuns) * 100) : 0
+  const totalCostUsd = runs.reduce((sum, r) => sum + (r.costUsd || 0), 0)
+
+  // Calculate average duration (only completed runs)
+  const completedRuns = runs.filter(r => r.durationMs != null)
+  const avgDurationMs = completedRuns.length > 0
+    ? Math.round(completedRuns.reduce((sum, r) => sum + (r.durationMs || 0), 0) / completedRuns.length)
+    : 0
+
+  // Get last run time
+  const lastRun = runs.length > 0
+    ? runs.reduce((latest, r) => r.startedAt > latest.startedAt ? r : latest)
+    : null
+  const lastRunAt = lastRun?.startedAt.toISOString() || null
+
+  // Get daily breakdown for chart
+  const dailyRunsMap = new Map<string, DailyRunData>()
+
+  for (const run of runs) {
+    const date = run.startedAt.toISOString().split('T')[0]!
+    const existing = dailyRunsMap.get(date) || {
+      date,
+      success: 0,
+      error: 0,
+      total: 0,
+      costUsd: 0
+    }
+
+    existing.total++
+    if (run.status === 'success') {
+      existing.success++
+    } else if (run.status === 'error' || run.status === 'budget_exceeded' || run.status === 'cancelled') {
+      existing.error++
+    }
+    existing.costUsd += run.costUsd || 0
+
+    dailyRunsMap.set(date, existing)
+  }
+
+  // Sort by date
+  const dailyRuns = Array.from(dailyRunsMap.values()).sort((a, b) => a.date.localeCompare(b.date))
+
+  const stats: AgentDetailStats = {
+    totalRuns,
+    successRate,
+    avgDurationMs,
+    totalCostUsd,
+    lastRunAt,
+    dailyRuns
+  }
+
+  return { data: stats }
+})

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

@@ -0,0 +1,29 @@
+import { eq } from 'drizzle-orm'
+import { getDb, schema } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+import { unscheduleAgent } from '~~/server/services/cron-scheduler'
+
+export default defineEventHandler(async (event) => {
+  requireDb(event)
+
+  const id = getRouterParam(event, 'id')
+  if (!id) {
+    throw createError({ statusCode: 400, message: 'Agent ID is required' })
+  }
+
+  const db = getDb()
+
+  // Unschedule before deleting
+  unscheduleAgent(id)
+
+  // Delete agent (runs will cascade delete)
+  const [deleted] = await db.delete(schema.cronAgents)
+    .where(eq(schema.cronAgents.id, id))
+    .returning()
+
+  if (!deleted) {
+    throw createError({ statusCode: 404, message: 'Agent not found' })
+  }
+
+  return { data: deleted }
+})

package/server/api/agents/[id].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: 'Agent ID is required' })
+  }
+
+  const db = getDb()
+
+  const agent = await db.query.cronAgents.findFirst({
+    where: eq(schema.cronAgents.id, id),
+    with: { creator: true }
+  })
+
+  if (!agent) {
+    throw createError({ statusCode: 404, message: 'Agent not found' })
+  }
+
+  return { data: agent }
+})

package/server/api/agents/[id].patch.ts

@@ -0,0 +1,55 @@
+import { eq } from 'drizzle-orm'
+import { getDb, schema } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+import { scheduleAgent, unscheduleAgent } from '~~/server/services/cron-scheduler'
+
+interface UpdateAgentBody {
+  name?: string
+  description?: string
+  schedule?: string
+  prompt?: string
+  enabled?: boolean
+  maxTurns?: number
+  maxBudgetUsd?: number | null
+}
+
+export default defineEventHandler(async (event) => {
+  requireDb(event)
+
+  const id = getRouterParam(event, 'id')
+  if (!id) {
+    throw createError({ statusCode: 400, message: 'Agent ID is required' })
+  }
+
+  const body = await readBody<UpdateAgentBody>(event)
+  const db = getDb()
+
+  // Get existing agent
+  const existing = await db.query.cronAgents.findFirst({
+    where: eq(schema.cronAgents.id, id)
+  })
+
+  if (!existing) {
+    throw createError({ statusCode: 404, message: 'Agent not found' })
+  }
+
+  // Update agent
+  const [agent] = await db.update(schema.cronAgents)
+    .set({
+      ...body,
+      updatedAt: new Date()
+    })
+    .where(eq(schema.cronAgents.id, id))
+    .returning()
+
+  // Reschedule if schedule or enabled changed
+  if (body.schedule !== undefined || body.enabled !== undefined) {
+    if (agent!.enabled) {
+      scheduleAgent(agent!)
+    } else {
+      unscheduleAgent(agent!.id)
+    }
+  }
+
+  return { data: agent }
+})

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

@@ -0,0 +1,15 @@
+import { getDb } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+
+export default defineEventHandler(async (event) => {
+  requireDb(event)
+
+  const db = getDb()
+
+  const agents = await db.query.cronAgents.findMany({
+    with: { creator: true },
+    orderBy: (agents, { asc }) => [asc(agents.name)]
+  })
+
+  return { data: agents }
+})

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

@@ -0,0 +1,48 @@
+import { getDb, schema } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+import { scheduleAgent } from '~~/server/services/cron-scheduler'
+
+interface CreateAgentBody {
+  name: string
+  description?: string
+  schedule: string
+  prompt: string
+  enabled?: boolean
+  maxTurns?: number
+  maxBudgetUsd?: number
+}
+
+export default defineEventHandler(async (event) => {
+  requireDb(event)
+
+  const body = await readBody<CreateAgentBody>(event)
+
+  if (!body.name || !body.schedule || !body.prompt) {
+    throw createError({
+      statusCode: 400,
+      message: 'Name, schedule, and prompt are required'
+    })
+  }
+
+  const db = getDb()
+
+  const [agent] = await db.insert(schema.cronAgents)
+    .values({
+      name: body.name,
+      description: body.description,
+      schedule: body.schedule,
+      prompt: body.prompt,
+      enabled: body.enabled ?? true,
+      maxTurns: body.maxTurns ?? 50,
+      maxBudgetUsd: body.maxBudgetUsd,
+      createdBy: event.context.user?.id
+    })
+    .returning()
+
+  // Schedule if enabled
+  if (agent!.enabled) {
+    scheduleAgent(agent!)
+  }
+
+  return { data: agent }
+})

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

@@ -0,0 +1,86 @@
+import { gte } from 'drizzle-orm'
+import { getDb, schema } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+import type { StatsPeriod, AgentGlobalStats, DailyRunData } 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 agent counts
+  const agents = await db.query.cronAgents.findMany()
+  const totalAgents = agents.length
+  const activeAgents = agents.filter(a => a.enabled).length
+
+  // Get runs in period with aggregations
+  const runsInPeriod = await db.query.cronAgentRuns.findMany({
+    where: gte(schema.cronAgentRuns.startedAt, periodStart)
+  })
+
+  const totalRuns = runsInPeriod.length
+  const successfulRuns = runsInPeriod.filter(r => r.status === 'success').length
+  const successRate = totalRuns > 0 ? Math.round((successfulRuns / totalRuns) * 100) : 0
+  const totalCostUsd = runsInPeriod.reduce((sum, r) => sum + (r.costUsd || 0), 0)
+
+  // Get running agent IDs
+  const runningAgentIds = runsInPeriod
+    .filter(r => r.status === 'running')
+    .map(r => r.agentId)
+    .filter((id, index, arr) => arr.indexOf(id) === index) // unique
+
+  // Get daily breakdown for chart
+  const dailyRunsMap = new Map<string, DailyRunData>()
+
+  for (const run of runsInPeriod) {
+    const date = run.startedAt.toISOString().split('T')[0]!
+    const existing = dailyRunsMap.get(date) || {
+      date,
+      success: 0,
+      error: 0,
+      total: 0,
+      costUsd: 0
+    }
+
+    existing.total++
+    if (run.status === 'success') {
+      existing.success++
+    } else if (run.status === 'error' || run.status === 'budget_exceeded' || run.status === 'cancelled') {
+      existing.error++
+    }
+    existing.costUsd += run.costUsd || 0
+
+    dailyRunsMap.set(date, existing)
+  }
+
+  // Sort by date
+  const dailyRuns = Array.from(dailyRunsMap.values()).sort((a, b) => a.date.localeCompare(b.date))
+
+  const stats: AgentGlobalStats = {
+    totalAgents,
+    activeAgents,
+    runsInPeriod: totalRuns,
+    successRate,
+    totalCostUsd,
+    runningAgentIds,
+    dailyRuns
+  }
+
+  return { data: stats }
+})

package/server/api/auth/[...all].ts

@@ -0,0 +1,5 @@
+import { auth } from '~~/server/utils/auth'
+
+export default defineEventHandler(async (event) => {
+  return auth.handler(toWebRequest(event))
+})