cognova 0.1.0

package/app/composables/useFileTree.ts

@@ -0,0 +1,220 @@
+import type { FileEntry } from '~/../../shared/types'
+
+export interface TreeItem {
+  id: string
+  label: string
+  icon?: string
+  path: string
+  type: 'file' | 'directory'
+  children?: TreeItem[]
+  defaultExpanded?: boolean
+}
+
+export function useFileTree() {
+  const items = ref<TreeItem[]>([])
+  const selectedFile = ref<string | null>(null)
+  const loading = ref(false)
+  const error = ref<string | null>(null)
+  const searchQuery = ref('')
+
+  function fileEntryToTreeItem(entry: FileEntry, expandRoot = false): TreeItem {
+    const icon = entry.type === 'directory'
+      ? undefined
+      : getFileIcon(entry.name)
+
+    return {
+      id: entry.path,
+      label: entry.name,
+      icon,
+      path: entry.path,
+      type: entry.type,
+      defaultExpanded: expandRoot,
+      children: entry.children?.map(child => fileEntryToTreeItem(child))
+    }
+  }
+
+  function getFileIcon(filename: string): string {
+    const ext = filename.split('.').pop()?.toLowerCase()
+    switch (ext) {
+      case 'md':
+        return 'i-lucide-file-text'
+      case 'ts':
+      case 'tsx':
+        return 'i-lucide-file-code'
+      case 'js':
+      case 'jsx':
+        return 'i-lucide-file-code'
+      case 'vue':
+        return 'i-lucide-file-code'
+      case 'json':
+        return 'i-lucide-file-json'
+      case 'css':
+      case 'scss':
+        return 'i-lucide-file-code'
+      case 'png':
+      case 'jpg':
+      case 'jpeg':
+      case 'gif':
+      case 'svg':
+        return 'i-lucide-file-image'
+      default:
+        return 'i-lucide-file'
+    }
+  }
+
+  async function loadTree(path = '/') {
+    loading.value = true
+    error.value = null
+
+    try {
+      const response = await $fetch<{ data: FileEntry[] }>('/api/fs/list', {
+        query: { path, recursive: 'true' }
+      })
+
+      items.value = response.data.map(entry => fileEntryToTreeItem(entry, true))
+    } catch (e) {
+      error.value = 'Failed to load file tree'
+      console.error('Failed to load file tree:', e)
+    } finally {
+      loading.value = false
+    }
+  }
+
+  async function readFile(path: string) {
+    try {
+      const response = await $fetch<{ data: { content: string, path: string, modifiedAt: string } }>('/api/fs/read', {
+        method: 'POST',
+        body: { path }
+      })
+      return response.data
+    } catch (e) {
+      console.error('Failed to read file:', e)
+      throw e
+    }
+  }
+
+  async function writeFile(path: string, content: string) {
+    try {
+      const response = await $fetch<{ data: { path: string, created: boolean } }>('/api/fs/write', {
+        method: 'POST',
+        body: { path, content }
+      })
+      return response.data
+    } catch (e) {
+      console.error('Failed to write file:', e)
+      throw e
+    }
+  }
+
+  async function createFile(parentPath: string, filename: string) {
+    const path = parentPath === '/' ? `/${filename}` : `${parentPath}/${filename}`
+    await writeFile(path, '')
+    await loadTree()
+    return path
+  }
+
+  async function createFolder(parentPath: string, foldername: string) {
+    const path = parentPath === '/' ? `/${foldername}` : `${parentPath}/${foldername}`
+    try {
+      await $fetch('/api/fs/mkdir', {
+        method: 'POST',
+        body: { path }
+      })
+      await loadTree()
+      return path
+    } catch (e) {
+      console.error('Failed to create folder:', e)
+      throw e
+    }
+  }
+
+  async function renameItem(oldPath: string, newName: string) {
+    const parts = oldPath.split('/')
+    parts.pop()
+    const newPath = [...parts, newName].join('/')
+
+    try {
+      await $fetch('/api/fs/rename', {
+        method: 'POST',
+        body: { oldPath, newPath }
+      })
+      await loadTree()
+      return newPath
+    } catch (e) {
+      console.error('Failed to rename:', e)
+      throw e
+    }
+  }
+
+  async function deleteItem(path: string) {
+    try {
+      await $fetch('/api/fs/delete', {
+        method: 'POST',
+        body: { path }
+      })
+      if (selectedFile.value === path) {
+        selectedFile.value = null
+      }
+      await loadTree()
+    } catch (e) {
+      console.error('Failed to delete:', e)
+      throw e
+    }
+  }
+
+  async function moveItem(sourcePath: string, destinationPath: string) {
+    try {
+      const response = await $fetch<{ data: { oldPath: string, newPath: string, moved: boolean } }>('/api/fs/move', {
+        method: 'POST',
+        body: { sourcePath, destinationPath }
+      })
+      await loadTree()
+      return response.data.newPath
+    } catch (e) {
+      console.error('Failed to move:', e)
+      throw e
+    }
+  }
+
+  const filteredItems = computed(() => {
+    if (!searchQuery.value) return items.value
+
+    const query = searchQuery.value.toLowerCase()
+
+    function filterTree(items: TreeItem[]): TreeItem[] {
+      return items.reduce<TreeItem[]>((acc, item) => {
+        const matches = item.label.toLowerCase().includes(query)
+        const filteredChildren = item.children ? filterTree(item.children) : []
+
+        if (matches || filteredChildren.length > 0) {
+          acc.push({
+            ...item,
+            children: filteredChildren.length > 0 ? filteredChildren : item.children,
+            defaultExpanded: filteredChildren.length > 0 || matches
+          })
+        }
+
+        return acc
+      }, [])
+    }
+
+    return filterTree(items.value)
+  })
+
+  return {
+    items,
+    filteredItems,
+    selectedFile,
+    loading,
+    error,
+    searchQuery,
+    loadTree,
+    readFile,
+    writeFile,
+    createFile,
+    createFolder,
+    renameItem,
+    deleteItem,
+    moveItem
+  }
+}

package/app/composables/useHookEvents.ts

@@ -0,0 +1,68 @@
+import type { HookEvent, HookEventStats, HookEventFilters, StatsPeriod } from '~~/shared/types'
+
+export function useHookEvents() {
+  const events = ref<HookEvent[]>([])
+  const stats = ref<HookEventStats | null>(null)
+  const loading = ref(false)
+  const error = ref<string | null>(null)
+
+  async function fetchEvents(filters?: HookEventFilters) {
+    loading.value = true
+    error.value = null
+
+    try {
+      const response = await $fetch<{ data: HookEvent[] }>('/api/hooks/events', {
+        query: filters
+      })
+      events.value = response.data
+      return response.data
+    } catch (e) {
+      error.value = 'Failed to load hook events'
+      console.error('Failed to load hook events:', e)
+      throw e
+    } finally {
+      loading.value = false
+    }
+  }
+
+  async function fetchStats(period: StatsPeriod = '7d') {
+    loading.value = true
+    error.value = null
+
+    try {
+      const response = await $fetch<{ data: HookEventStats }>('/api/hooks/stats', {
+        query: { period }
+      })
+      stats.value = response.data
+      return response.data
+    } catch (e) {
+      error.value = 'Failed to load hook stats'
+      console.error('Failed to load hook stats:', e)
+      throw e
+    } finally {
+      loading.value = false
+    }
+  }
+
+  async function fetchEventsBySession(sessionId: string, limit = 100) {
+    try {
+      const response = await $fetch<{ data: HookEvent[] }>('/api/hooks/events', {
+        query: { sessionId, limit }
+      })
+      return response.data
+    } catch (e) {
+      console.error('Failed to fetch session events:', e)
+      throw e
+    }
+  }
+
+  return {
+    events,
+    stats,
+    loading,
+    error,
+    fetchEvents,
+    fetchStats,
+    fetchEventsBySession
+  }
+}

package/app/composables/useMemories.ts

@@ -0,0 +1,83 @@
+import type { MemoryChunk, MemoryChunkType } from '~~/shared/types'
+
+interface MemoryFilters {
+  query?: string
+  chunkType?: MemoryChunkType | 'all'
+  projectPath?: string
+  limit?: number
+}
+
+export function useMemories() {
+  const memories = ref<MemoryChunk[]>([])
+  const loading = ref(true) // Start true to avoid SSR rendering issues
+  const error = ref<string | null>(null)
+
+  const filters = reactive<MemoryFilters>({
+    query: '',
+    chunkType: 'all',
+    limit: 50
+  })
+
+  async function fetchMemories(customFilters?: Partial<MemoryFilters>) {
+    loading.value = true
+    error.value = null
+
+    const queryFilters = { ...filters, ...customFilters }
+
+    try {
+      const query: Record<string, string> = {}
+
+      if (queryFilters.query)
+        query.query = queryFilters.query
+      if (queryFilters.chunkType && queryFilters.chunkType !== 'all')
+        query.chunkType = queryFilters.chunkType
+      if (queryFilters.projectPath)
+        query.projectPath = queryFilters.projectPath
+      if (queryFilters.limit)
+        query.limit = String(queryFilters.limit)
+
+      const response = await $fetch<{ data: MemoryChunk[] }>('/api/memory/search', { query })
+      memories.value = response.data
+      return response.data
+    } catch (e) {
+      error.value = 'Failed to load memories'
+      console.error('Failed to load memories:', e)
+      throw e
+    } finally {
+      loading.value = false
+    }
+  }
+
+  async function deleteMemory(id: string) {
+    try {
+      await $fetch(`/api/memory/${id}`, { method: 'DELETE' })
+      memories.value = memories.value.filter(m => m.id !== id)
+    } catch (e) {
+      console.error('Failed to delete memory:', e)
+      throw e
+    }
+  }
+
+  // Computed stats
+  const stats = computed(() => {
+    const byType = memories.value.reduce((acc, m) => {
+      acc[m.chunkType] = (acc[m.chunkType] || 0) + 1
+      return acc
+    }, {} as Record<string, number>)
+
+    return {
+      total: memories.value.length,
+      byType
+    }
+  })
+
+  return {
+    memories,
+    loading,
+    error,
+    filters,
+    stats,
+    fetchMemories,
+    deleteMemory
+  }
+}

package/app/composables/useNotificationBus.ts

@@ -0,0 +1,154 @@
+import type { NotificationPayload } from '~~/shared/types'
+
+export type NotificationBusStatus = 'disconnected' | 'connecting' | 'connected' | 'error'
+
+// Shared state across all component instances
+const status = ref<NotificationBusStatus>('disconnected')
+const runningAgentIds = ref<Set<string>>(new Set())
+const ws = ref<WebSocket | null>(null)
+const reconnectAttempts = ref(0)
+const maxReconnectAttempts = 5
+const reconnectDelay = 2000
+let pingInterval: ReturnType<typeof setInterval> | null = null
+let isInitialized = false
+
+export function useNotificationBus() {
+  const toast = useToast()
+
+  function getWebSocketUrl(): string {
+    if (import.meta.server) return ''
+    const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:'
+    return `${protocol}//${window.location.host}/notifications`
+  }
+
+  function handleNotification(payload: NotificationPayload) {
+    // Update running agents state
+    if (payload.type === 'agent:started' && payload.agentId) {
+      runningAgentIds.value.add(payload.agentId)
+    } else if ((payload.type === 'agent:completed' || payload.type === 'agent:failed') && payload.agentId) {
+      runningAgentIds.value.delete(payload.agentId)
+    }
+
+    // Show toast for agent events
+    if (payload.type === 'agent:started') {
+      toast.add({
+        title: 'Agent Started',
+        description: payload.agentName || 'An agent has started running',
+        icon: 'i-lucide-play',
+        color: 'info'
+      })
+    } else if (payload.type === 'agent:completed') {
+      toast.add({
+        title: 'Agent Completed',
+        description: payload.agentName || 'Agent run completed successfully',
+        icon: 'i-lucide-check-circle',
+        color: 'success'
+      })
+    } else if (payload.type === 'agent:failed') {
+      toast.add({
+        title: 'Agent Failed',
+        description: payload.message || payload.agentName || 'Agent run failed',
+        icon: 'i-lucide-alert-circle',
+        color: 'error'
+      })
+    } else if (payload.type === 'toast' && payload.title) {
+      toast.add({
+        title: payload.title,
+        description: payload.message,
+        color: payload.color || 'info'
+      })
+    }
+  }
+
+  function connect() {
+    if (import.meta.server) return
+    if (ws.value?.readyState === WebSocket.OPEN) return
+    if (isInitialized && status.value === 'connecting') return
+
+    isInitialized = true
+    status.value = 'connecting'
+
+    const socket = new WebSocket(getWebSocketUrl())
+    ws.value = socket
+
+    socket.onopen = () => {
+      status.value = 'connected'
+      reconnectAttempts.value = 0
+      console.log('[notification-bus] Connected')
+      startPingInterval()
+    }
+
+    socket.onmessage = (event) => {
+      try {
+        const data = JSON.parse(event.data) as Record<string, unknown>
+        const msgType = data.type as string
+
+        // Skip pong and connected messages
+        if (msgType === 'pong' || msgType === 'connected') return
+
+        // Only handle known notification types
+        if (msgType === 'agent:started' || msgType === 'agent:completed' || msgType === 'agent:failed' || msgType === 'toast') {
+          handleNotification(data as unknown as NotificationPayload)
+        }
+      } catch (e) {
+        console.error('[notification-bus] Failed to parse message:', e)
+      }
+    }
+
+    socket.onclose = () => {
+      status.value = 'disconnected'
+      stopPingInterval()
+
+      // Attempt reconnection
+      if (reconnectAttempts.value < maxReconnectAttempts) {
+        reconnectAttempts.value++
+        console.log(`[notification-bus] Reconnecting (attempt ${reconnectAttempts.value})...`)
+        setTimeout(connect, reconnectDelay * reconnectAttempts.value)
+      }
+    }
+
+    socket.onerror = () => {
+      status.value = 'error'
+    }
+  }
+
+  function disconnect() {
+    stopPingInterval()
+    if (ws.value) {
+      ws.value.close()
+      ws.value = null
+    }
+    status.value = 'disconnected'
+    isInitialized = false
+  }
+
+  function sendPing() {
+    if (ws.value?.readyState === WebSocket.OPEN) {
+      ws.value.send(JSON.stringify({ type: 'ping' }))
+    }
+  }
+
+  function startPingInterval() {
+    if (pingInterval) clearInterval(pingInterval)
+    pingInterval = setInterval(sendPing, 30000)
+  }
+
+  function stopPingInterval() {
+    if (pingInterval) {
+      clearInterval(pingInterval)
+      pingInterval = null
+    }
+  }
+
+  function isAgentRunning(agentId: string): boolean {
+    return runningAgentIds.value.has(agentId)
+  }
+
+  return {
+    status: readonly(status),
+    runningAgentIds: readonly(runningAgentIds),
+    isAgentRunning,
+    connect,
+    disconnect
+  }
+}

package/app/composables/usePreferences.ts

@@ -0,0 +1,131 @@
+import type { TaskStatus } from '~~/shared/types'
+
+interface Preferences {
+  // Editor preferences
+  editorMode: 'editor' | 'code'
+  viewSourceMode: boolean
+
+  // Navigation
+  lastDocumentPath: string | null
+
+  // Layout
+  sidebarOpen: boolean
+  docsTreeWidth: number
+  assistantPanelOpen: boolean
+  assistantPanelTab: 'chat' | 'terminal'
+  assistantLastConversationId: string | null
+
+  // Task filters
+  taskStatusFilter: TaskStatus | 'all'
+  taskProjectFilter: string | null
+
+  // Agent stats
+  agentStatsPeriod: '24h' | '7d' | '30d'
+}
+
+const COOKIE_NAME = 'sb-preferences'
+const COOKIE_MAX_AGE = 60 * 60 * 24 * 365 // 1 year
+
+const defaults: Preferences = {
+  editorMode: 'editor',
+  viewSourceMode: false,
+  lastDocumentPath: null,
+  sidebarOpen: true,
+  docsTreeWidth: 16,
+  assistantPanelOpen: false,
+  assistantPanelTab: 'chat',
+  assistantLastConversationId: null,
+  taskStatusFilter: 'all',
+  taskProjectFilter: null,
+  agentStatsPeriod: '7d'
+}
+
+export function usePreferences() {
+  const cookie = useCookie<Partial<Preferences>>(COOKIE_NAME, {
+    maxAge: COOKIE_MAX_AGE,
+    default: () => ({})
+  })
+
+  function get<K extends keyof Preferences>(key: K): Preferences[K] {
+    return cookie.value[key] ?? defaults[key]
+  }
+
+  function set<K extends keyof Preferences>(key: K, value: Preferences[K]) {
+    cookie.value = { ...cookie.value, [key]: value }
+  }
+
+  // Convenience computed refs for common preferences
+  const editorMode = computed({
+    get: () => get('editorMode'),
+    set: v => set('editorMode', v)
+  })
+
+  const viewSourceMode = computed({
+    get: () => get('viewSourceMode'),
+    set: v => set('viewSourceMode', v)
+  })
+
+  const lastDocumentPath = computed({
+    get: () => get('lastDocumentPath'),
+    set: v => set('lastDocumentPath', v)
+  })
+
+  const sidebarOpen = computed({
+    get: () => get('sidebarOpen'),
+    set: v => set('sidebarOpen', v)
+  })
+
+  const docsTreeWidth = computed({
+    get: () => get('docsTreeWidth'),
+    set: v => set('docsTreeWidth', v)
+  })
+
+  const taskStatusFilter = computed({
+    get: () => get('taskStatusFilter'),
+    set: v => set('taskStatusFilter', v)
+  })
+
+  const taskProjectFilter = computed({
+    get: () => get('taskProjectFilter'),
+    set: v => set('taskProjectFilter', v)
+  })
+
+  const agentStatsPeriod = computed({
+    get: () => get('agentStatsPeriod'),
+    set: v => set('agentStatsPeriod', v)
+  })
+
+  const assistantPanelOpen = computed({
+    get: () => get('assistantPanelOpen'),
+    set: v => set('assistantPanelOpen', v)
+  })
+
+  const assistantPanelTab = computed({
+    get: () => get('assistantPanelTab'),
+    set: v => set('assistantPanelTab', v)
+  })
+
+  const assistantLastConversationId = computed({
+    get: () => get('assistantLastConversationId'),
+    set: v => set('assistantLastConversationId', v)
+  })
+
+  return {
+    // Raw access
+    get,
+    set,
+
+    // Computed refs
+    editorMode,
+    viewSourceMode,
+    lastDocumentPath,
+    sidebarOpen,
+    docsTreeWidth,
+    assistantPanelOpen,
+    assistantPanelTab,
+    assistantLastConversationId,
+    taskStatusFilter,
+    taskProjectFilter,
+    agentStatsPeriod
+  }
+}