cognova 0.1.9 → 0.2.0

package/app/pages/usage.vue

@@ -0,0 +1,130 @@
+<script setup lang="ts">
+import type { StatsPeriod, UsageStats } from '~~/shared/types'
+
+definePageMeta({
+  layout: 'dashboard',
+  middleware: 'auth'
+})
+
+const { usageStatsPeriod } = usePreferences()
+const period = ref<StatsPeriod>(usageStatsPeriod.value)
+const granularity = ref<'daily' | 'hourly'>('daily')
+const stats = ref<UsageStats | null>(null)
+const loading = ref(false)
+
+const periodOptions = [
+  { label: '24h', value: '24h' as StatsPeriod },
+  { label: '7d', value: '7d' as StatsPeriod },
+  { label: '30d', value: '30d' as StatsPeriod }
+]
+
+async function loadStats() {
+  loading.value = true
+  try {
+    const res = await $fetch<{ data: UsageStats }>('/api/usage/stats', {
+      query: {
+        period: period.value,
+        granularity: granularity.value,
+        tzOffset: new Date().getTimezoneOffset()
+      }
+    })
+    stats.value = res.data
+  } catch {
+    // Silently fail
+  } finally {
+    loading.value = false
+  }
+}
+
+watch(period, (value) => {
+  usageStatsPeriod.value = value
+  loadStats()
+})
+
+watch(granularity, () => {
+  loadStats()
+})
+
+onMounted(() => {
+  loadStats()
+})
+</script>
+
+<template>
+  <div class="contents">
+    <UDashboardPanel
+      id="usage"
+      grow
+    >
+      <template #header>
+        <UDashboardNavbar title="Token Usage">
+          <template #right>
+            <UFieldGroup>
+              <UButton
+                v-for="opt in periodOptions"
+                :key="opt.value"
+                :color="period === opt.value ? 'primary' : 'neutral'"
+                :variant="period === opt.value ? 'solid' : 'ghost'"
+                size="sm"
+                @click="period = opt.value"
+              >
+                {{ opt.label }}
+              </UButton>
+            </UFieldGroup>
+          </template>
+        </UDashboardNavbar>
+      </template>
+
+      <template #body>
+        <div class="p-4 space-y-6">
+          <UsageStatsCards
+            :stats="stats"
+            :loading="loading"
+          />
+
+          <UsageCostChart
+            v-if="stats && stats.dailyUsage.length > 0"
+            v-model:granularity="granularity"
+            :data="stats.dailyUsage"
+            title="Cost Over Time"
+          />
+
+          <div class="grid gap-6 lg:grid-cols-2">
+            <UsageSourceDonut
+              v-if="stats && stats.bySource.length > 0"
+              :data="stats.bySource"
+              title="Cost by Source"
+            />
+
+            <UsageTopConsumers
+              v-if="stats && stats.topConsumers.length > 0"
+              :data="stats.topConsumers"
+              title="Top Consumers"
+            />
+          </div>
+
+          <UsageRecordsTable
+            v-if="stats && stats.totalCalls > 0"
+            :period="period"
+          />
+
+          <div
+            v-if="!loading && stats && stats.totalCalls === 0"
+            class="flex flex-col items-center justify-center h-64 text-muted"
+          >
+            <UIcon
+              name="i-lucide-bar-chart-3"
+              class="size-12 mb-4"
+            />
+            <p class="text-lg font-medium">
+              No usage data yet
+            </p>
+            <p class="text-sm mt-1">
+              Token usage will appear here once you start using chat or agents
+            </p>
+          </div>
+        </div>
+      </template>
+    </UDashboardPanel>
+  </div>
+</template>

package/app/pages/view/[uuid].vue

@@ -60,18 +60,19 @@ watch(viewSource, v => viewSourceMode.value = v)
 
 // Copy content to clipboard
 const toast = useToast()
+const { copy } = useCopyToClipboard()
 async function copyContent() {
   const content = data.value?.data?.content
   if (!content) return
 
-  try {
-    await navigator.clipboard.writeText(content)
+  const ok = await copy(content)
+  if (ok) {
     toast.add({
       title: 'Copied to clipboard',
       icon: 'i-lucide-check',
       color: 'success'
     })
-  } catch {
+  } else {
     toast.add({
       title: 'Failed to copy',
       icon: 'i-lucide-x',

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "cognova",
   "type": "module",
-  "version": "0.1.9",
+  "version": "0.2.0",
   "description": "Personal knowledge management system with Claude Code integration",
   "repository": {
     "type": "git",

package/server/api/dashboard/overview.get.ts

@@ -0,0 +1,133 @@
+import { eq, isNull, and, inArray, gte, desc, sql, ne } from 'drizzle-orm'
+import { getDb, schema } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+import type { DashboardOverview } from '~~/shared/types'
+
+export default defineEventHandler(async (event) => {
+  requireDb(event)
+
+  const db = getDb()
+  const sevenDaysAgo = new Date(Date.now() - 7 * 24 * 60 * 60 * 1000)
+
+  const [taskCounts, upcomingTasks, recentConversations, recentDocuments, usageAgg] = await Promise.all([
+    // Task counts: todo + in_progress (not deleted)
+    db.select({
+      status: schema.tasks.status,
+      count: sql<number>`count(*)::int`
+    })
+      .from(schema.tasks)
+      .where(and(
+        isNull(schema.tasks.deletedAt),
+        inArray(schema.tasks.status, ['todo', 'in_progress'])
+      ))
+      .groupBy(schema.tasks.status),
+
+    // Top 5 upcoming tasks (not done, not deleted)
+    db.select({
+      id: schema.tasks.id,
+      title: schema.tasks.title,
+      status: schema.tasks.status,
+      priority: schema.tasks.priority,
+      dueDate: schema.tasks.dueDate,
+      projectName: schema.projects.name,
+      projectColor: schema.projects.color
+    })
+      .from(schema.tasks)
+      .leftJoin(schema.projects, eq(schema.tasks.projectId, schema.projects.id))
+      .where(and(
+        isNull(schema.tasks.deletedAt),
+        ne(schema.tasks.status, 'done')
+      ))
+      .orderBy(
+        sql`${schema.tasks.dueDate} ASC NULLS LAST`,
+        desc(schema.tasks.priority)
+      )
+      .limit(5),
+
+    // Last 3 conversations
+    db.select({
+      id: schema.conversations.id,
+      sessionId: schema.conversations.sessionId,
+      title: schema.conversations.title,
+      messageCount: schema.conversations.messageCount,
+      startedAt: schema.conversations.startedAt
+    })
+      .from(schema.conversations)
+      .orderBy(desc(schema.conversations.startedAt))
+      .limit(3),
+
+    // Last 3 documents (not deleted)
+    db.select({
+      id: schema.documents.id,
+      title: schema.documents.title,
+      path: schema.documents.path,
+      modifiedAt: schema.documents.modifiedAt,
+      projectName: schema.projects.name,
+      projectColor: schema.projects.color
+    })
+      .from(schema.documents)
+      .leftJoin(schema.projects, eq(schema.documents.projectId, schema.projects.id))
+      .where(isNull(schema.documents.deletedAt))
+      .orderBy(desc(schema.documents.modifiedAt))
+      .limit(3),
+
+    // 7-day usage summary
+    db.select({
+      totalCost: sql<number>`coalesce(sum(${schema.tokenUsage.costUsd}), 0)::real`,
+      totalCalls: sql<number>`count(*)::int`,
+      totalInputTokens: sql<number>`coalesce(sum(${schema.tokenUsage.inputTokens}), 0)::int`,
+      totalOutputTokens: sql<number>`coalesce(sum(${schema.tokenUsage.outputTokens}), 0)::int`
+    })
+      .from(schema.tokenUsage)
+      .where(gte(schema.tokenUsage.createdAt, sevenDaysAgo))
+  ])
+
+  // Build task counts
+  let todoCount = 0
+  let inProgressCount = 0
+  for (const row of taskCounts) {
+    if (row.status === 'todo') todoCount = row.count
+    else if (row.status === 'in_progress') inProgressCount = row.count
+  }
+
+  const usageRow = usageAgg[0]
+
+  const overview: DashboardOverview = {
+    tasks: {
+      todoCount,
+      inProgressCount,
+      upcoming: upcomingTasks.map(t => ({
+        id: t.id,
+        title: t.title,
+        status: t.status as DashboardOverview['tasks']['upcoming'][0]['status'],
+        priority: t.priority,
+        dueDate: t.dueDate?.toISOString() ?? null,
+        projectName: t.projectName ?? null,
+        projectColor: t.projectColor ?? null
+      }))
+    },
+    conversations: recentConversations.map(c => ({
+      id: c.id,
+      sessionId: c.sessionId,
+      title: c.title ?? null,
+      messageCount: c.messageCount,
+      startedAt: c.startedAt.toISOString()
+    })),
+    documents: recentDocuments.map(d => ({
+      id: d.id,
+      title: d.title,
+      path: d.path,
+      modifiedAt: d.modifiedAt?.toISOString() ?? null,
+      projectName: d.projectName ?? null,
+      projectColor: d.projectColor ?? null
+    })),
+    usage: {
+      totalCost7d: usageRow?.totalCost ?? 0,
+      totalCalls7d: usageRow?.totalCalls ?? 0,
+      totalInputTokens7d: usageRow?.totalInputTokens ?? 0,
+      totalOutputTokens7d: usageRow?.totalOutputTokens ?? 0
+    }
+  }
+
+  return { data: overview }
+})

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

@@ -0,0 +1,69 @@
+import { and, gte, eq, ilike, desc } from 'drizzle-orm'
+import { getDb, schema } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+import type { StatsPeriod, TokenUsageSource } 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)
+  }
+}
+
+const VALID_SOURCES: TokenUsageSource[] = ['chat', 'agent', 'memory_extraction']
+
+export default defineEventHandler(async (event) => {
+  requireDb(event)
+
+  const query = getQuery(event)
+  const period = (query.period as StatsPeriod) || '7d'
+  const source = query.source as TokenUsageSource | undefined
+  const search = query.search as string | undefined
+  const page = Math.max(1, Number(query.page) || 1)
+  const limit = Math.min(100, Math.max(1, Number(query.limit) || 20))
+  const offset = (page - 1) * limit
+
+  const periodStart = getPeriodInterval(period)
+  const db = getDb()
+
+  // Build conditions
+  const conditions = [gte(schema.tokenUsage.createdAt, periodStart)]
+
+  if (source && VALID_SOURCES.includes(source))
+    conditions.push(eq(schema.tokenUsage.source, source))
+
+  if (search && search.trim())
+    conditions.push(ilike(schema.tokenUsage.sourceName, `%${search.trim()}%`))
+
+  const where = and(...conditions)
+
+  // Get total count
+  const allMatching = await db.select({ id: schema.tokenUsage.id })
+    .from(schema.tokenUsage)
+    .where(where)
+
+  const total = allMatching.length
+
+  // Get paginated records
+  const records = await db.select()
+    .from(schema.tokenUsage)
+    .where(where)
+    .orderBy(desc(schema.tokenUsage.createdAt))
+    .limit(limit)
+    .offset(offset)
+
+  return {
+    data: records,
+    pagination: {
+      page,
+      limit,
+      total,
+      totalPages: Math.ceil(total / limit)
+    }
+  }
+})

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

@@ -0,0 +1,127 @@
+import { gte } from 'drizzle-orm'
+import { getDb, schema } from '~~/server/db'
+import { requireDb } from '~~/server/utils/db-guard'
+import type { StatsPeriod, UsageStats, DailyUsageData, TokenUsageSource } 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)
+  }
+}
+
+/**
+ * Get a bucket key for the given timestamp, adjusted to the client's timezone.
+ * tzOffset is in minutes (same as Date.getTimezoneOffset(), positive = behind UTC).
+ */
+function getBucketKey(date: Date, granularity: string, tzOffsetMs: number): string {
+  const local = new Date(date.getTime() - tzOffsetMs)
+  const iso = local.toISOString()
+  if (granularity === 'hourly')
+    return iso.slice(0, 13) // "2026-02-18T05"
+  return iso.slice(0, 10) // "2026-02-18"
+}
+
+export default defineEventHandler(async (event) => {
+  requireDb(event)
+
+  const query = getQuery(event)
+  const period = (query.period as StatsPeriod) || '7d'
+  const granularity = (query.granularity as string) === 'hourly' ? 'hourly' : 'daily'
+  const tzOffset = Number(query.tzOffset) || 0 // minutes from UTC
+  const tzOffsetMs = tzOffset * 60 * 1000
+  const periodStart = getPeriodInterval(period)
+
+  const db = getDb()
+
+  // Get all usage records in period
+  const records = await db.select()
+    .from(schema.tokenUsage)
+    .where(gte(schema.tokenUsage.createdAt, periodStart))
+
+  // Aggregate totals
+  let totalCostUsd = 0
+  let totalInputTokens = 0
+  let totalOutputTokens = 0
+  const totalCalls = records.length
+
+  // Time-series breakdown
+  const bucketMap = new Map<string, DailyUsageData>()
+
+  // By source breakdown
+  const sourceMap = new Map<TokenUsageSource, { cost: number, calls: number, tokens: number }>()
+
+  // Top consumers
+  const consumerMap = new Map<string, { name: string, source: TokenUsageSource, cost: number, calls: number }>()
+
+  for (const r of records) {
+    totalCostUsd += r.costUsd
+    totalInputTokens += r.inputTokens
+    totalOutputTokens += r.outputTokens
+
+    // Time-series bucket (timezone-aware)
+    const bucket = getBucketKey(r.createdAt, granularity, tzOffsetMs)
+    const existing = bucketMap.get(bucket) || {
+      date: bucket,
+      chat: 0,
+      agent: 0,
+      memory: 0,
+      totalCost: 0,
+      inputTokens: 0,
+      outputTokens: 0,
+      calls: 0
+    }
+    existing.totalCost += r.costUsd
+    existing.inputTokens += r.inputTokens
+    existing.outputTokens += r.outputTokens
+    existing.calls++
+    if (r.source === 'chat') existing.chat += r.costUsd
+    else if (r.source === 'agent') existing.agent += r.costUsd
+    else if (r.source === 'memory_extraction') existing.memory += r.costUsd
+    bucketMap.set(bucket, existing)
+
+    // By source
+    const source = r.source as TokenUsageSource
+    const srcEntry = sourceMap.get(source) || { cost: 0, calls: 0, tokens: 0 }
+    srcEntry.cost += r.costUsd
+    srcEntry.calls++
+    srcEntry.tokens += r.inputTokens + r.outputTokens
+    sourceMap.set(source, srcEntry)
+
+    // Top consumers (group by sourceName)
+    const consumerKey = `${r.source}:${r.sourceName || 'Unknown'}`
+    const consumer = consumerMap.get(consumerKey) || {
+      name: r.sourceName || 'Unknown',
+      source,
+      cost: 0,
+      calls: 0
+    }
+    consumer.cost += r.costUsd
+    consumer.calls++
+    consumerMap.set(consumerKey, consumer)
+  }
+
+  const dailyUsage = Array.from(bucketMap.values()).sort((a, b) => a.date.localeCompare(b.date))
+  const bySource = Array.from(sourceMap.entries()).map(([source, data]) => ({ source, ...data }))
+  const topConsumers = Array.from(consumerMap.values())
+    .sort((a, b) => b.cost - a.cost)
+    .slice(0, 10)
+
+  const stats: UsageStats = {
+    totalCostUsd,
+    totalInputTokens,
+    totalOutputTokens,
+    totalCalls,
+    avgCostPerCall: totalCalls > 0 ? totalCostUsd / totalCalls : 0,
+    dailyUsage,
+    bySource,
+    topConsumers
+  }
+
+  return { data: stats }
+})

package/server/db/schema.ts

@@ -359,3 +359,20 @@ export const userSettings = pgTable('user_settings', {
 export const userSettingsRelations = relations(userSettings, ({ one }) => ({
   user: one(user, { fields: [userSettings.userId], references: [user.id] })
 }))
+
+// =============================================================================
+// Token Usage - Unified AI cost & token tracking
+// =============================================================================
+
+export const tokenUsage = pgTable('token_usage', {
+  id: uuid('id').primaryKey().defaultRandom(),
+  source: text('source', { enum: ['chat', 'agent', 'memory_extraction'] }).notNull(),
+  sourceId: text('source_id'),
+  sourceName: text('source_name'),
+  inputTokens: integer('input_tokens').default(0).notNull(),
+  outputTokens: integer('output_tokens').default(0).notNull(),
+  costUsd: real('cost_usd').default(0).notNull(),
+  durationMs: integer('duration_ms'),
+  numTurns: integer('num_turns'),
+  createdAt: timestamp('created_at', { withTimezone: true }).defaultNow().notNull()
+})

package/server/drizzle/migrations/0011_tearful_johnny_storm.sql

@@ -0,0 +1,12 @@
+CREATE TABLE "token_usage" (
+	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
+	"source" text NOT NULL,
+	"source_id" text,
+	"source_name" text,
+	"input_tokens" integer DEFAULT 0 NOT NULL,
+	"output_tokens" integer DEFAULT 0 NOT NULL,
+	"cost_usd" real DEFAULT 0 NOT NULL,
+	"duration_ms" integer,
+	"num_turns" integer,
+	"created_at" timestamp with time zone DEFAULT now() NOT NULL
+);