clawport-ui 0.1.0

package/lib/kanban/store.test.ts

@@ -0,0 +1,238 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import {
+  loadTickets,
+  saveTickets,
+  createTicket,
+  updateTicket,
+  moveTicket,
+  deleteTicket,
+  getTicketsByStatus,
+  type KanbanStore,
+} from './store'
+
+// Mock localStorage
+const storage: Record<string, string> = {}
+beforeEach(() => {
+  Object.keys(storage).forEach((k) => delete storage[k])
+  vi.stubGlobal('localStorage', {
+    getItem: (key: string) => storage[key] ?? null,
+    setItem: (key: string, val: string) => { storage[key] = val },
+    removeItem: (key: string) => { delete storage[key] },
+  })
+})
+
+// Mock crypto.randomUUID
+beforeEach(() => {
+  let counter = 0
+  vi.stubGlobal('crypto', {
+    randomUUID: () => `test-uuid-${++counter}`,
+  })
+})
+
+// Default work state fields for test tickets
+const WORK_DEFAULTS = { workState: 'idle' as const, workStartedAt: null, workError: null, workResult: null }
+
+describe('loadTickets', () => {
+  it('returns empty object when nothing stored', () => {
+    expect(loadTickets()).toEqual({})
+  })
+
+  it('returns parsed data from localStorage', () => {
+    const data = { 'id-1': { id: 'id-1', title: 'Test' } }
+    storage['clawport-kanban'] = JSON.stringify(data)
+    const loaded = loadTickets()
+    expect(loaded['id-1'].id).toBe('id-1')
+    expect(loaded['id-1'].title).toBe('Test')
+    // Backfilled work state fields
+    expect(loaded['id-1'].workState).toBe('idle')
+    expect(loaded['id-1'].workStartedAt).toBeNull()
+    expect(loaded['id-1'].workError).toBeNull()
+  })
+
+  it('returns empty object on invalid JSON', () => {
+    storage['clawport-kanban'] = 'not-json'
+    expect(loadTickets()).toEqual({})
+  })
+})
+
+describe('saveTickets', () => {
+  it('persists to localStorage', () => {
+    const store: KanbanStore = {}
+    saveTickets(store)
+    expect(storage['clawport-kanban']).toBe('{}')
+  })
+})
+
+describe('createTicket', () => {
+  it('adds a ticket with generated id and timestamps', () => {
+    const store: KanbanStore = {}
+    const result = createTicket(store, {
+      title: 'New ticket',
+      description: 'Do the thing',
+      status: 'backlog',
+      priority: 'medium',
+      assigneeId: null,
+      assigneeRole: null,
+    })
+
+    const ticket = result['test-uuid-1']
+    expect(ticket).toBeDefined()
+    expect(ticket.title).toBe('New ticket')
+    expect(ticket.status).toBe('backlog')
+    expect(ticket.id).toBe('test-uuid-1')
+    expect(ticket.createdAt).toBeTypeOf('number')
+    expect(ticket.updatedAt).toBe(ticket.createdAt)
+  })
+
+  it('preserves existing tickets', () => {
+    const store: KanbanStore = {
+      existing: {
+        id: 'existing',
+        title: 'Existing',
+        description: '',
+        status: 'todo',
+        priority: 'low',
+        assigneeId: null,
+        assigneeRole: null,
+        ...WORK_DEFAULTS,
+        createdAt: 1000,
+        updatedAt: 1000,
+      },
+    }
+    const result = createTicket(store, {
+      title: 'New',
+      description: '',
+      status: 'backlog',
+      priority: 'medium',
+      assigneeId: null,
+      assigneeRole: null,
+    })
+    expect(result['existing']).toBeDefined()
+    expect(Object.keys(result)).toHaveLength(2)
+  })
+})
+
+describe('updateTicket', () => {
+  const baseStore: KanbanStore = {
+    't1': {
+      id: 't1',
+      title: 'Original',
+      description: 'Desc',
+      status: 'backlog',
+      priority: 'low',
+      assigneeId: null,
+      assigneeRole: null,
+      ...WORK_DEFAULTS,
+      createdAt: 1000,
+      updatedAt: 1000,
+    },
+  }
+
+  it('updates specified fields', () => {
+    const result = updateTicket(baseStore, 't1', { title: 'Updated' })
+    expect(result['t1'].title).toBe('Updated')
+    expect(result['t1'].description).toBe('Desc')
+    expect(result['t1'].updatedAt).toBeGreaterThan(1000)
+  })
+
+  it('returns store unchanged for missing ticket', () => {
+    const result = updateTicket(baseStore, 'missing', { title: 'X' })
+    expect(result).toBe(baseStore)
+  })
+})
+
+describe('moveTicket', () => {
+  it('changes ticket status', () => {
+    const store: KanbanStore = {
+      't1': {
+        id: 't1',
+        title: 'Task',
+        description: '',
+        status: 'backlog',
+        priority: 'medium',
+        assigneeId: null,
+        assigneeRole: null,
+        ...WORK_DEFAULTS,
+        createdAt: 1000,
+        updatedAt: 1000,
+      },
+    }
+    const result = moveTicket(store, 't1', 'in-progress')
+    expect(result['t1'].status).toBe('in-progress')
+  })
+})
+
+describe('deleteTicket', () => {
+  it('removes the ticket', () => {
+    const store: KanbanStore = {
+      't1': {
+        id: 't1',
+        title: 'Task',
+        description: '',
+        status: 'backlog',
+        priority: 'medium',
+        assigneeId: null,
+        assigneeRole: null,
+        ...WORK_DEFAULTS,
+        createdAt: 1000,
+        updatedAt: 1000,
+      },
+    }
+    const result = deleteTicket(store, 't1')
+    expect(result['t1']).toBeUndefined()
+  })
+
+  it('preserves other tickets', () => {
+    const store: KanbanStore = {
+      't1': {
+        id: 't1', title: 'A', description: '', status: 'backlog',
+        priority: 'low', assigneeId: null, assigneeRole: null,
+        ...WORK_DEFAULTS, createdAt: 1000, updatedAt: 1000,
+      },
+      't2': {
+        id: 't2', title: 'B', description: '', status: 'todo',
+        priority: 'high', assigneeId: null, assigneeRole: null,
+        ...WORK_DEFAULTS, createdAt: 2000, updatedAt: 2000,
+      },
+    }
+    const result = deleteTicket(store, 't1')
+    expect(result['t2']).toBeDefined()
+    expect(Object.keys(result)).toHaveLength(1)
+  })
+})
+
+describe('getTicketsByStatus', () => {
+  const store: KanbanStore = {
+    't1': {
+      id: 't1', title: 'Old', description: '', status: 'backlog',
+      priority: 'low', assigneeId: null, assigneeRole: null,
+      ...WORK_DEFAULTS, createdAt: 1000, updatedAt: 1000,
+    },
+    't2': {
+      id: 't2', title: 'New', description: '', status: 'backlog',
+      priority: 'medium', assigneeId: null, assigneeRole: null,
+      ...WORK_DEFAULTS, createdAt: 2000, updatedAt: 3000,
+    },
+    't3': {
+      id: 't3', title: 'Other', description: '', status: 'todo',
+      priority: 'high', assigneeId: null, assigneeRole: null,
+      ...WORK_DEFAULTS, createdAt: 1500, updatedAt: 1500,
+    },
+  }
+
+  it('filters by status', () => {
+    const backlog = getTicketsByStatus(store, 'backlog')
+    expect(backlog).toHaveLength(2)
+    expect(backlog.every((t) => t.status === 'backlog')).toBe(true)
+  })
+
+  it('sorts by updatedAt descending', () => {
+    const backlog = getTicketsByStatus(store, 'backlog')
+    expect(backlog[0].id).toBe('t2')
+    expect(backlog[1].id).toBe('t1')
+  })
+
+  it('returns empty array for empty column', () => {
+    expect(getTicketsByStatus(store, 'done')).toEqual([])
+  })
+})

package/lib/kanban/store.ts

@@ -0,0 +1,98 @@
+'use client'
+
+import type { KanbanTicket, TicketStatus } from './types'
+
+export type KanbanStore = Record<string, KanbanTicket>
+
+const STORAGE_KEY = 'clawport-kanban'
+
+export function loadTickets(): KanbanStore {
+  if (typeof window === 'undefined') return {}
+  try {
+    const raw = localStorage.getItem(STORAGE_KEY)
+    if (!raw) return {}
+    const store: KanbanStore = JSON.parse(raw)
+    // Backfill work state fields for existing tickets
+    for (const id of Object.keys(store)) {
+      store[id] = {
+        ...store[id],
+        workState: store[id].workState ?? 'idle',
+        workStartedAt: store[id].workStartedAt ?? null,
+        workError: store[id].workError ?? null,
+        workResult: store[id].workResult ?? null,
+      }
+    }
+    return store
+  } catch {
+    return {}
+  }
+}
+
+export function saveTickets(store: KanbanStore): void {
+  if (typeof window === 'undefined') return
+  try {
+    localStorage.setItem(STORAGE_KEY, JSON.stringify(store))
+  } catch {}
+}
+
+export function createTicket(
+  store: KanbanStore,
+  ticket: Omit<KanbanTicket, 'id' | 'createdAt' | 'updatedAt' | 'workState' | 'workStartedAt' | 'workError' | 'workResult'> & {
+    workState?: KanbanTicket['workState']
+    workStartedAt?: KanbanTicket['workStartedAt']
+    workError?: KanbanTicket['workError']
+    workResult?: KanbanTicket['workResult']
+  },
+): KanbanStore {
+  const id = crypto.randomUUID()
+  const now = Date.now()
+  return {
+    ...store,
+    [id]: {
+      ...ticket,
+      id,
+      workState: ticket.workState ?? 'idle',
+      workStartedAt: ticket.workStartedAt ?? null,
+      workError: ticket.workError ?? null,
+      workResult: ticket.workResult ?? null,
+      createdAt: now,
+      updatedAt: now,
+    },
+  }
+}
+
+export function updateTicket(
+  store: KanbanStore,
+  id: string,
+  updates: Partial<Omit<KanbanTicket, 'id' | 'createdAt'>>,
+): KanbanStore {
+  const existing = store[id]
+  if (!existing) return store
+  return {
+    ...store,
+    [id]: { ...existing, ...updates, updatedAt: Date.now() },
+  }
+}
+
+export function moveTicket(
+  store: KanbanStore,
+  id: string,
+  status: TicketStatus,
+): KanbanStore {
+  return updateTicket(store, id, { status })
+}
+
+export function deleteTicket(store: KanbanStore, id: string): KanbanStore {
+  const next = { ...store }
+  delete next[id]
+  return next
+}
+
+export function getTicketsByStatus(
+  store: KanbanStore,
+  status: TicketStatus,
+): KanbanTicket[] {
+  return Object.values(store)
+    .filter((t) => t.status === status)
+    .sort((a, b) => b.updatedAt - a.updatedAt)
+}

package/lib/kanban/types.ts

@@ -0,0 +1,50 @@
+// Kanban board types
+
+export type TicketStatus = 'backlog' | 'todo' | 'in-progress' | 'review' | 'done'
+
+export type TicketPriority = 'low' | 'medium' | 'high'
+
+export type TeamRole = 'lead-dev' | 'ux-ui' | 'qa'
+
+export type WorkState = 'idle' | 'starting' | 'working' | 'done' | 'failed'
+
+export interface KanbanTicket {
+  id: string
+  title: string
+  description: string
+  status: TicketStatus
+  priority: TicketPriority
+  assigneeId: string | null   // agent id from agents.json
+  assigneeRole: TeamRole | null
+  workState: WorkState
+  workStartedAt: number | null
+  workError: string | null
+  workResult: string | null
+  createdAt: number
+  updatedAt: number
+}
+
+export interface KanbanColumn {
+  id: TicketStatus
+  title: string
+}
+
+export const COLUMNS: KanbanColumn[] = [
+  { id: 'backlog', title: 'Backlog' },
+  { id: 'todo', title: 'To Do' },
+  { id: 'in-progress', title: 'In Progress' },
+  { id: 'review', title: 'Review' },
+  { id: 'done', title: 'Done' },
+]
+
+export const PRIORITY_COLORS: Record<TicketPriority, string> = {
+  low: 'var(--system-green)',
+  medium: 'var(--system-orange)',
+  high: 'var(--system-red)',
+}
+
+export const ROLE_LABELS: Record<TeamRole, string> = {
+  'lead-dev': 'Lead Dev',
+  'ux-ui': 'UX/UI Lead',
+  'qa': 'QA',
+}

package/lib/kanban/useAgentWork.ts

@@ -0,0 +1,78 @@
+'use client'
+
+import { useEffect, useRef, useCallback } from 'react'
+import type { KanbanTicket, TicketStatus } from './types'
+import type { KanbanStore } from './store'
+import { executeWork, getWorkPrompt, persistWorkChat } from './automation'
+
+interface UseAgentWorkOptions {
+  tickets: KanbanStore
+  onUpdateTicket: (ticketId: string, updates: Partial<KanbanTicket>) => void
+}
+
+export function useAgentWork({ tickets, onUpdateTicket }: UseAgentWorkOptions) {
+  const activeWork = useRef<Set<string>>(new Set())
+
+  const runWork = useCallback(async (ticket: KanbanTicket) => {
+    const { id, assigneeId } = ticket
+    if (!assigneeId) return
+
+    // Move to in-progress + set working state
+    onUpdateTicket(id, {
+      status: 'in-progress' as TicketStatus,
+      workState: 'working',
+      workStartedAt: Date.now(),
+      workError: null,
+    })
+
+    const result = await executeWork(assigneeId, ticket)
+
+    if (result.success) {
+      // Save chat history so TicketDetailPanel picks it up
+      const prompt = getWorkPrompt(ticket)
+      persistWorkChat(id, prompt, result.content)
+
+      // Move to review with result
+      onUpdateTicket(id, {
+        status: 'review' as TicketStatus,
+        workState: 'done',
+        workResult: result.content,
+      })
+    } else {
+      // Stay in-progress with error
+      onUpdateTicket(id, {
+        workState: 'failed',
+        workError: result.error || 'Agent work failed',
+      })
+    }
+
+    activeWork.current.delete(id)
+  }, [onUpdateTicket])
+
+  // Scan for eligible tickets
+  useEffect(() => {
+    const eligible = Object.values(tickets).filter(
+      (t) => t.status === 'todo' && t.assigneeId && t.workState === 'idle',
+    )
+
+    for (const ticket of eligible) {
+      if (activeWork.current.has(ticket.id)) continue
+
+      // Mark as active immediately to prevent double-execution
+      activeWork.current.add(ticket.id)
+
+      // Set starting state synchronously to prevent re-triggers on next render
+      onUpdateTicket(ticket.id, { workState: 'starting' })
+
+      // Fire async work
+      runWork(ticket)
+    }
+  }, [tickets, onUpdateTicket, runWork])
+
+  const isWorking = useCallback(
+    (ticketId: string): boolean => activeWork.current.has(ticketId),
+    [],
+  )
+
+  return { isWorking }
+}

package/lib/memory.ts

@@ -0,0 +1,45 @@
+import { MemoryFile } from '@/lib/types'
+import { readFileSync, existsSync, statSync } from 'fs'
+import { requireEnv } from '@/lib/env'
+
+function readMemoryFile(label: string, filePath: string): MemoryFile | null {
+  try {
+    if (!existsSync(filePath)) return null
+    const content = readFileSync(filePath, 'utf-8')
+    const stats = statSync(filePath)
+    return {
+      label,
+      path: filePath,
+      content,
+      lastModified: stats.mtime.toISOString(),
+    }
+  } catch {
+    return null
+  }
+}
+
+export async function getMemoryFiles(): Promise<MemoryFile[]> {
+  const workspacePath = requireEnv('WORKSPACE_PATH')
+  const today = new Date()
+  const yesterday = new Date(today)
+  yesterday.setDate(yesterday.getDate() - 1)
+
+  const todayStr = today.toISOString().slice(0, 10)
+  const yesterdayStr = yesterday.toISOString().slice(0, 10)
+
+  const candidates: [string, string][] = [
+    ['Long-Term Memory (Jarvis)', workspacePath + '/MEMORY.md'],
+    ['Team Memory', workspacePath + '/memory/team-memory.md'],
+    ['Team Intel (JSON)', workspacePath + '/memory/team-intel.json'],
+    ['Daily Log (Today)', workspacePath + '/memory/' + todayStr + '.md'],
+    ['Daily Log (Yesterday)', workspacePath + '/memory/' + yesterdayStr + '.md'],
+  ]
+
+  const files: MemoryFile[] = []
+  for (const [label, path] of candidates) {
+    const file = readMemoryFile(label, path)
+    if (file) files.push(file)
+  }
+
+  return files
+}