cognova 0.1.0

package/app/composables/useProjects.ts

@@ -0,0 +1,97 @@
+import type { Project, CreateProjectInput, UpdateProjectInput } from '~~/shared/types'
+
+export function useProjects() {
+  const projects = ref<Project[]>([])
+  const loading = ref(false)
+  const error = ref<string | null>(null)
+
+  async function fetchProjects(includeDeleted = false) {
+    loading.value = true
+    error.value = null
+
+    try {
+      const response = await $fetch<{ data: Project[] }>('/api/projects', {
+        query: { includeDeleted: includeDeleted.toString() }
+      })
+      projects.value = response.data
+      return response.data
+    } catch (e) {
+      error.value = 'Failed to load projects'
+      console.error('Failed to load projects:', e)
+      throw e
+    } finally {
+      loading.value = false
+    }
+  }
+
+  async function getProject(id: string) {
+    try {
+      const response = await $fetch<{ data: Project }>(`/api/projects/${id}`)
+      return response.data
+    } catch (e) {
+      console.error('Failed to get project:', e)
+      throw e
+    }
+  }
+
+  async function createProject(input: CreateProjectInput) {
+    try {
+      const response = await $fetch<{ data: Project }>('/api/projects', {
+        method: 'POST',
+        body: input
+      })
+      projects.value = [...projects.value, response.data]
+      return response.data
+    } catch (e) {
+      console.error('Failed to create project:', e)
+      throw e
+    }
+  }
+
+  async function updateProject(id: string, input: UpdateProjectInput) {
+    try {
+      const response = await $fetch<{ data: Project }>(`/api/projects/${id}`, {
+        method: 'PUT',
+        body: input
+      })
+      const index = projects.value.findIndex(p => p.id === id)
+      if (index !== -1)
+        projects.value[index] = response.data
+      return response.data
+    } catch (e) {
+      console.error('Failed to update project:', e)
+      throw e
+    }
+  }
+
+  async function deleteProject(id: string) {
+    try {
+      const response = await $fetch<{ data: Project }>(`/api/projects/${id}`, {
+        method: 'DELETE'
+      })
+      projects.value = projects.value.filter(p => p.id !== id)
+      return response.data
+    } catch (e) {
+      console.error('Failed to delete project:', e)
+      throw e
+    }
+  }
+
+  // Get project by ID from local state
+  function getProjectById(id: string | undefined | null): Project | undefined {
+    if (!id) return undefined
+    return projects.value.find(p => p.id === id)
+  }
+
+  return {
+    projects,
+    loading,
+    error,
+    fetchProjects,
+    getProject,
+    createProject,
+    updateProject,
+    deleteProject,
+    getProjectById
+  }
+}

package/app/composables/useSearch.ts

@@ -0,0 +1,52 @@
+import { refDebounced } from '@vueuse/core'
+import type { Task, Document } from '~~/shared/types'
+
+export interface SearchResults {
+  tasks: Task[]
+  documents: Document[]
+}
+
+export function useSearch() {
+  const searchTerm = ref('')
+  const debouncedSearchTerm = refDebounced(searchTerm, 300)
+  const loading = ref(false)
+  const results = ref<SearchResults>({
+    tasks: [],
+    documents: []
+  })
+
+  watch(debouncedSearchTerm, async (term) => {
+    if (!term || term.length < 2) {
+      results.value = { tasks: [], documents: [] }
+      return
+    }
+
+    loading.value = true
+    try {
+      const [tasksRes, docsRes] = await Promise.all([
+        $fetch<{ data: Task[] }>('/api/tasks', { query: { search: term } }),
+        $fetch<{ data: Document[] }>('/api/documents', { query: { search: term } })
+      ])
+      results.value = {
+        tasks: tasksRes.data.slice(0, 5),
+        documents: docsRes.data.slice(0, 5)
+      }
+    } catch {
+      results.value = { tasks: [], documents: [] }
+    } finally {
+      loading.value = false
+    }
+  })
+
+  function reset() {
+    searchTerm.value = ''
+    results.value = { tasks: [], documents: [] }
+  }
+
+  return {
+    searchTerm,
+    loading,
+    results,
+    reset
+  }
+}

package/app/composables/useTasks.ts

@@ -0,0 +1,201 @@
+import type { Task, CreateTaskInput, UpdateTaskInput, TaskFilters, TaskStatus } from '~~/shared/types'
+
+export function useTasks() {
+  const tasks = ref<Task[]>([])
+  const loading = ref(false)
+  const error = ref<string | null>(null)
+  const tags = ref<string[]>([])
+
+  // Filter state
+  const filters = reactive<TaskFilters>({
+    status: undefined,
+    projectId: undefined,
+    search: undefined,
+    includeDeleted: false
+  })
+
+  async function fetchTasks(customFilters?: TaskFilters) {
+    loading.value = true
+    error.value = null
+
+    const queryFilters = customFilters || filters
+
+    try {
+      const query: Record<string, string> = {}
+
+      if (queryFilters.status) {
+        if (Array.isArray(queryFilters.status))
+          queryFilters.status.forEach(s => query.status = s)
+        else
+          query.status = queryFilters.status
+      }
+      if (queryFilters.projectId)
+        query.projectId = queryFilters.projectId
+      if (queryFilters.search)
+        query.search = queryFilters.search
+      if (queryFilters.includeDeleted)
+        query.includeDeleted = 'true'
+
+      const response = await $fetch<{ data: Task[] }>('/api/tasks', { query })
+      tasks.value = response.data
+      return response.data
+    } catch (e) {
+      error.value = 'Failed to load tasks'
+      console.error('Failed to load tasks:', e)
+      throw e
+    } finally {
+      loading.value = false
+    }
+  }
+
+  async function fetchTags() {
+    try {
+      const response = await $fetch<{ data: string[] }>('/api/tasks/tags')
+      tags.value = response.data
+      return response.data
+    } catch (e) {
+      console.error('Failed to fetch tags:', e)
+      throw e
+    }
+  }
+
+  async function getTask(id: string) {
+    try {
+      const response = await $fetch<{ data: Task }>(`/api/tasks/${id}`)
+      return response.data
+    } catch (e) {
+      console.error('Failed to get task:', e)
+      throw e
+    }
+  }
+
+  async function createTask(input: CreateTaskInput) {
+    try {
+      const response = await $fetch<{ data: Task }>('/api/tasks', {
+        method: 'POST',
+        body: input
+      })
+      tasks.value = [response.data, ...tasks.value]
+      return response.data
+    } catch (e) {
+      console.error('Failed to create task:', e)
+      throw e
+    }
+  }
+
+  async function updateTask(id: string, input: UpdateTaskInput) {
+    try {
+      const response = await $fetch<{ data: Task }>(`/api/tasks/${id}`, {
+        method: 'PUT',
+        body: input
+      })
+      const index = tasks.value.findIndex(t => t.id === id)
+      if (index !== -1)
+        tasks.value[index] = response.data
+      return response.data
+    } catch (e) {
+      console.error('Failed to update task:', e)
+      throw e
+    }
+  }
+
+  async function deleteTask(id: string) {
+    try {
+      const response = await $fetch<{ data: Task }>(`/api/tasks/${id}`, {
+        method: 'DELETE'
+      })
+      tasks.value = tasks.value.filter(t => t.id !== id)
+      return response.data
+    } catch (e) {
+      console.error('Failed to delete task:', e)
+      throw e
+    }
+  }
+
+  async function restoreTask(id: string) {
+    try {
+      const response = await $fetch<{ data: Task }>(`/api/tasks/${id}/restore`, {
+        method: 'POST'
+      })
+      // Re-fetch to update the list properly
+      await fetchTasks()
+      return response.data
+    } catch (e) {
+      console.error('Failed to restore task:', e)
+      throw e
+    }
+  }
+
+  // Quick status toggle (for checkbox)
+  async function toggleComplete(id: string) {
+    const task = tasks.value.find(t => t.id === id)
+    if (!task) return
+
+    const newStatus: TaskStatus = task.status === 'done' ? 'todo' : 'done'
+    return updateTask(id, { status: newStatus })
+  }
+
+  // Computed filtered tasks (client-side filtering for instant feedback)
+  const filteredTasks = computed(() => {
+    let result = [...tasks.value]
+
+    if (filters.status) {
+      const statuses = Array.isArray(filters.status) ? filters.status : [filters.status]
+      result = result.filter(t => statuses.includes(t.status))
+    }
+
+    if (filters.projectId)
+      result = result.filter(t => t.projectId === filters.projectId)
+
+    if (filters.search) {
+      const search = filters.search.toLowerCase()
+      result = result.filter(t =>
+        t.title.toLowerCase().includes(search)
+        || t.description?.toLowerCase().includes(search)
+      )
+    }
+
+    if (!filters.includeDeleted)
+      result = result.filter(t => !t.deletedAt)
+
+    return result
+  })
+
+  // Task counts by status
+  const taskCounts = computed(() => {
+    const counts = {
+      todo: 0,
+      in_progress: 0,
+      done: 0,
+      blocked: 0,
+      total: 0
+    }
+
+    tasks.value.forEach((task) => {
+      if (!task.deletedAt) {
+        counts[task.status]++
+        counts.total++
+      }
+    })
+
+    return counts
+  })
+
+  return {
+    tasks,
+    filteredTasks,
+    loading,
+    error,
+    tags,
+    filters,
+    taskCounts,
+    fetchTasks,
+    fetchTags,
+    getTask,
+    createTask,
+    updateTask,
+    deleteTask,
+    restoreTask,
+    toggleComplete
+  }
+}

package/app/composables/useTerminal.ts

@@ -0,0 +1,135 @@
+import type { Terminal } from '@xterm/xterm'
+
+export type ConnectionStatus = 'disconnected' | 'connecting' | 'connected' | 'error'
+
+interface TerminalMessage {
+  type: 'output' | 'pong' | 'error'
+  data?: string
+}
+
+export function useTerminal() {
+  const status = ref<ConnectionStatus>('disconnected')
+  const terminal = ref<Terminal | null>(null)
+  const ws = ref<WebSocket | null>(null)
+  const reconnectAttempts = ref(0)
+  const maxReconnectAttempts = 5
+  const reconnectDelay = 2000
+
+  function getWebSocketUrl(): string {
+    const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:'
+    return `${protocol}//${window.location.host}/terminal`
+  }
+
+  function connect(term: Terminal) {
+    terminal.value = term
+    status.value = 'connecting'
+
+    const socket = new WebSocket(getWebSocketUrl())
+    ws.value = socket
+
+    socket.onopen = () => {
+      status.value = 'connected'
+      reconnectAttempts.value = 0
+
+      // Send initial size
+      sendResize(term.cols, term.rows)
+    }
+
+    socket.onmessage = (event) => {
+      try {
+        const msg = JSON.parse(event.data) as TerminalMessage
+
+        if (msg.type === 'output' && msg.data) {
+          term.write(msg.data)
+        } else if (msg.type === 'error' && msg.data) {
+          status.value = 'error'
+          term.write(`\x1b[31m${msg.data}\x1b[0m`)
+        }
+      } catch {
+        // Handle raw data if not JSON
+        term.write(event.data)
+      }
+    }
+
+    socket.onclose = () => {
+      status.value = 'disconnected'
+
+      // Attempt reconnection
+      if (reconnectAttempts.value < maxReconnectAttempts) {
+        reconnectAttempts.value++
+        setTimeout(() => {
+          if (terminal.value) {
+            connect(terminal.value)
+          }
+        }, reconnectDelay)
+      }
+    }
+
+    socket.onerror = () => {
+      status.value = 'error'
+    }
+  }
+
+  function disconnect() {
+    if (ws.value) {
+      ws.value.close()
+      ws.value = null
+    }
+    status.value = 'disconnected'
+  }
+
+  function sendInput(data: string) {
+    if (ws.value?.readyState === WebSocket.OPEN) {
+      ws.value.send(JSON.stringify({
+        type: 'input',
+        data
+      }))
+    }
+  }
+
+  function sendResize(cols: number, rows: number) {
+    if (ws.value?.readyState === WebSocket.OPEN) {
+      ws.value.send(JSON.stringify({
+        type: 'resize',
+        cols,
+        rows
+      }))
+    }
+  }
+
+  function sendPing() {
+    if (ws.value?.readyState === WebSocket.OPEN) {
+      ws.value.send(JSON.stringify({ type: 'ping' }))
+    }
+  }
+
+  // Keep connection alive
+  let pingInterval: ReturnType<typeof setInterval> | null = null
+
+  function startPingInterval() {
+    if (pingInterval) clearInterval(pingInterval)
+    pingInterval = setInterval(sendPing, 30000)
+  }
+
+  function stopPingInterval() {
+    if (pingInterval) {
+      clearInterval(pingInterval)
+      pingInterval = null
+    }
+  }
+
+  onUnmounted(() => {
+    stopPingInterval()
+    disconnect()
+  })
+
+  return {
+    status,
+    connect,
+    disconnect,
+    sendInput,
+    sendResize,
+    startPingInterval,
+    stopPingInterval
+  }
+}

package/app/layouts/auth.vue

@@ -0,0 +1,20 @@
+<script setup lang="ts">
+</script>
+
+<template>
+  <div class="min-h-screen flex items-center justify-center bg-default">
+    <div class="w-full max-w-md px-4">
+      <div class="flex flex-col items-center gap-6 mb-8">
+        <div class="flex items-center gap-3">
+          <UIcon
+            name="i-lucide-brain"
+            class="size-10 text-primary"
+          />
+          <span class="font-bold text-2xl">Cognova</span>
+        </div>
+      </div>
+
+      <slot />
+    </div>
+  </div>
+</template>

package/app/layouts/dashboard.vue

@@ -0,0 +1,186 @@
+<script setup lang="ts">
+import type { NavigationMenuItem } from '@nuxt/ui'
+
+const { user, logout } = useAuth()
+const { sidebarOpen } = usePreferences()
+const open = ref(sidebarOpen.value)
+
+// Sync sidebar state to preference
+watch(open, v => sidebarOpen.value = v)
+
+// Initialize notification bus on client
+const { connect: connectNotificationBus } = useNotificationBus()
+onMounted(() => {
+  connectNotificationBus()
+})
+
+const links = [[{
+  label: 'Dashboard',
+  icon: 'i-lucide-home',
+  to: '/dashboard',
+  onSelect: () => {
+    open.value = false
+  }
+}, {
+  label: 'Docs',
+  icon: 'i-lucide-file-text',
+  to: '/docs',
+  onSelect: () => {
+    open.value = false
+  }
+}, {
+  label: 'Tasks',
+  icon: 'i-lucide-check-square',
+  to: '/tasks',
+  onSelect: () => {
+    open.value = false
+  }
+}, {
+  label: 'Agents',
+  icon: 'i-lucide-bot',
+  to: '/agents',
+  onSelect: () => {
+    open.value = false
+  }
+}, {
+  label: 'Hooks',
+  icon: 'i-lucide-webhook',
+  to: '/hooks',
+  onSelect: () => {
+    open.value = false
+  }
+}, {
+  label: 'Memories',
+  icon: 'i-lucide-brain',
+  to: '/memories',
+  onSelect: () => {
+    open.value = false
+  }
+}, {
+  label: 'Chat',
+  icon: 'i-lucide-message-square',
+  to: '/chat',
+  onSelect: () => {
+    open.value = false
+  }
+}, {
+  label: 'Settings',
+  icon: 'i-lucide-settings',
+  to: '/settings',
+  onSelect: () => {
+    open.value = false
+  }
+}]] satisfies NavigationMenuItem[][]
+</script>
+
+<template>
+  <UDashboardGroup unit="rem">
+    <UDashboardSidebar
+      id="main"
+      v-model:open="open"
+      collapsible
+      resizable
+      class="bg-elevated/25"
+      :ui="{ footer: 'lg:border-t lg:border-default' }"
+    >
+      <template #header="{ collapsed }">
+        <div class="flex items-center gap-2 px-2 py-1.5">
+          <UIcon
+            name="i-lucide-brain"
+            class="size-6 text-primary shrink-0"
+          />
+          <span
+            v-if="!collapsed"
+            class="font-semibold text-lg"
+          >Brain</span>
+        </div>
+      </template>
+
+      <template #default="{ collapsed }">
+        <ClientOnly>
+          <UDashboardSearchButton :collapsed="collapsed" />
+          <template #fallback>
+            <UButton
+              :label="collapsed ? undefined : 'Search...'"
+              icon="i-lucide-search"
+              color="neutral"
+              variant="ghost"
+              class="w-full justify-start"
+              :ui="{ trailingIcon: 'ms-auto' }"
+            >
+              <template
+                v-if="!collapsed"
+                #trailing
+              >
+                <UKbd>⌘K</UKbd>
+              </template>
+            </UButton>
+          </template>
+        </ClientOnly>
+
+        <UNavigationMenu
+          :collapsed="collapsed"
+          :items="links[0]"
+          orientation="vertical"
+          tooltip
+          popover
+        />
+      </template>
+
+      <template #footer="{ collapsed }">
+        <ClientOnly>
+          <UDropdownMenu
+            :items="[[
+              { label: 'Sign out', icon: 'i-lucide-log-out', onSelect: logout }
+            ]]"
+          >
+            <UButton
+              variant="ghost"
+              class="w-full justify-start"
+              :ui="{ leadingIcon: 'size-5' }"
+            >
+              <UAvatar
+                :alt="user?.name || 'User'"
+                size="2xs"
+              />
+              <span
+                v-if="!collapsed"
+                class="text-sm truncate"
+              >{{ user?.name || user?.email || 'User' }}</span>
+            </UButton>
+          </UDropdownMenu>
+
+          <template #fallback>
+            <UButton
+              variant="ghost"
+              class="w-full justify-start"
+              :ui="{ leadingIcon: 'size-5' }"
+            >
+              <USkeleton class="size-5 rounded-full" />
+              <USkeleton
+                v-if="!collapsed"
+                class="h-4 w-20"
+              />
+            </UButton>
+          </template>
+        </ClientOnly>
+      </template>
+    </UDashboardSidebar>
+
+    <ClientOnly>
+      <SearchDashboardSearch />
+      <template #fallback>
+        <span />
+      </template>
+    </ClientOnly>
+
+    <slot />
+
+    <ClientOnly>
+      <AssistantPanel />
+      <template #fallback>
+        <span />
+      </template>
+    </ClientOnly>
+  </UDashboardGroup>
+</template>