clawport-ui 0.1.0

package/lib/kanban/automation.test.ts

@@ -0,0 +1,245 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest'
+import { getWorkPrompt, executeWork, persistWorkChat } from './automation'
+import type { KanbanTicket } from './types'
+
+/* ── Helpers ─────────────────────────────────────────── */
+
+function makeTicket(overrides: Partial<KanbanTicket> = {}): KanbanTicket {
+  return {
+    id: 'ticket-1',
+    title: 'Build login page',
+    description: 'Implement login with email/password',
+    status: 'todo',
+    priority: 'high',
+    assigneeId: 'agent-1',
+    assigneeRole: 'lead-dev',
+    workState: 'idle',
+    workStartedAt: null,
+    workError: null,
+    workResult: null,
+    createdAt: 1000,
+    updatedAt: 1000,
+    ...overrides,
+  }
+}
+
+// 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}`,
+  })
+})
+
+/* ── getWorkPrompt ───────────────────────────────────── */
+
+describe('getWorkPrompt', () => {
+  it('returns lead-dev prompt for lead-dev role', () => {
+    const prompt = getWorkPrompt(makeTicket({ assigneeRole: 'lead-dev' }))
+    expect(prompt).toContain('Lead Dev')
+    expect(prompt).toContain('Technical breakdown')
+    expect(prompt).toContain('Implementation plan')
+    expect(prompt).toContain('Build login page')
+  })
+
+  it('returns ux-ui prompt for ux-ui role', () => {
+    const prompt = getWorkPrompt(makeTicket({ assigneeRole: 'ux-ui' }))
+    expect(prompt).toContain('UX/UI Lead')
+    expect(prompt).toContain('Design review')
+    expect(prompt).toContain('Accessibility')
+  })
+
+  it('returns qa prompt for qa role', () => {
+    const prompt = getWorkPrompt(makeTicket({ assigneeRole: 'qa' }))
+    expect(prompt).toContain('QA')
+    expect(prompt).toContain('Test scenarios')
+    expect(prompt).toContain('Acceptance criteria')
+  })
+
+  it('returns fallback prompt when no role assigned', () => {
+    const prompt = getWorkPrompt(makeTicket({ assigneeRole: null }))
+    expect(prompt).toContain('Analysis of what needs to be done')
+    expect(prompt).toContain('Build login page')
+  })
+
+  it('includes ticket description when present', () => {
+    const prompt = getWorkPrompt(makeTicket({ description: 'Custom desc' }))
+    expect(prompt).toContain('Description: Custom desc')
+  })
+
+  it('handles empty description', () => {
+    const prompt = getWorkPrompt(makeTicket({ description: '' }))
+    expect(prompt).toContain('No description provided')
+  })
+})
+
+/* ── executeWork ─────────────────────────────────────── */
+
+describe('executeWork', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('returns success with streamed content', async () => {
+    const sseData = [
+      'data: {"content":"Hello "}\n\n',
+      'data: {"content":"world"}\n\n',
+      'data: [DONE]\n\n',
+    ].join('')
+
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(new TextEncoder().encode(sseData))
+        controller.close()
+      },
+    })
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      body: stream,
+    }))
+
+    const result = await executeWork('agent-1', makeTicket())
+    expect(result.success).toBe(true)
+    expect(result.content).toBe('Hello world')
+  })
+
+  it('calls onChunk for each SSE chunk', async () => {
+    const sseData = 'data: {"content":"A"}\n\ndata: {"content":"B"}\n\ndata: [DONE]\n\n'
+
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(new TextEncoder().encode(sseData))
+        controller.close()
+      },
+    })
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      body: stream,
+    }))
+
+    const chunks: string[] = []
+    await executeWork('agent-1', makeTicket(), (c) => chunks.push(c))
+    expect(chunks).toEqual(['A', 'B'])
+  })
+
+  it('returns error on non-ok response', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: false,
+      status: 500,
+      body: null,
+    }))
+
+    const result = await executeWork('agent-1', makeTicket())
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('500')
+  })
+
+  it('returns error on empty response', async () => {
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(new TextEncoder().encode('data: [DONE]\n\n'))
+        controller.close()
+      },
+    })
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      body: stream,
+    }))
+
+    const result = await executeWork('agent-1', makeTicket())
+    expect(result.success).toBe(false)
+    expect(result.error).toContain('Empty response')
+  })
+
+  it('returns error on network failure', async () => {
+    vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('Network down')))
+
+    const result = await executeWork('agent-1', makeTicket())
+    expect(result.success).toBe(false)
+    expect(result.error).toBe('Network down')
+  })
+
+  it('skips malformed SSE chunks gracefully', async () => {
+    const sseData = 'data: {"content":"Good"}\n\ndata: not-json\n\ndata: {"content":"Also good"}\n\ndata: [DONE]\n\n'
+
+    const stream = new ReadableStream({
+      start(controller) {
+        controller.enqueue(new TextEncoder().encode(sseData))
+        controller.close()
+      },
+    })
+
+    vi.stubGlobal('fetch', vi.fn().mockResolvedValue({
+      ok: true,
+      body: stream,
+    }))
+
+    const result = await executeWork('agent-1', makeTicket())
+    expect(result.success).toBe(true)
+    expect(result.content).toBe('GoodAlso good')
+  })
+})
+
+/* ── persistWorkChat ─────────────────────────────────── */
+
+describe('persistWorkChat', () => {
+  let fetchMock: ReturnType<typeof vi.fn>
+
+  beforeEach(() => {
+    fetchMock = vi.fn().mockResolvedValue({ ok: true, json: () => Promise.resolve({ ok: true }) })
+    vi.stubGlobal('fetch', fetchMock)
+  })
+
+  it('posts prompt and response to chat-history API', () => {
+    persistWorkChat('ticket-1', 'Do the work', 'Here is the result')
+
+    expect(fetchMock).toHaveBeenCalledWith(
+      '/api/kanban/chat-history/ticket-1',
+      expect.objectContaining({
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+      }),
+    )
+
+    const body = JSON.parse(fetchMock.mock.calls[0][1].body)
+    expect(body.messages).toHaveLength(2)
+    expect(body.messages[0].role).toBe('user')
+    expect(body.messages[0].content).toBe('Do the work')
+    expect(body.messages[1].role).toBe('assistant')
+    expect(body.messages[1].content).toBe('Here is the result')
+  })
+
+  it('generates unique IDs for messages', () => {
+    persistWorkChat('ticket-1', 'Prompt', 'Response')
+
+    const body = JSON.parse(fetchMock.mock.calls[0][1].body)
+    expect(body.messages[0].id).toBe('test-uuid-1')
+    expect(body.messages[1].id).toBe('test-uuid-2')
+  })
+
+  it('sets assistant timestamp 1ms after user timestamp', () => {
+    persistWorkChat('ticket-1', 'Prompt', 'Response')
+
+    const body = JSON.parse(fetchMock.mock.calls[0][1].body)
+    expect(body.messages[1].timestamp).toBe(body.messages[0].timestamp + 1)
+  })
+
+  it('does not throw when fetch fails', () => {
+    fetchMock.mockRejectedValue(new Error('Network error'))
+    expect(() => persistWorkChat('ticket-1', 'Prompt', 'Response')).not.toThrow()
+  })
+})

package/lib/kanban/automation.ts

@@ -0,0 +1,143 @@
+'use client'
+
+import type { KanbanTicket, TeamRole } from './types'
+
+/* ── Role-specific work prompts ──────────────────────── */
+
+const ROLE_PROMPTS: Record<TeamRole, string> = {
+  'lead-dev': `You are working this ticket as the Lead Dev. Provide:
+1. Technical breakdown of the work needed
+2. Implementation plan with clear steps
+3. Key technical decisions or trade-offs
+4. Dependencies or blockers to flag
+
+Be specific and actionable. Reference concrete files, APIs, or patterns where relevant.`,
+
+  'ux-ui': `You are working this ticket as the UX/UI Lead. Provide:
+1. Design review and recommendations
+2. User flow walkthrough
+3. Accessibility considerations (WCAG)
+4. Visual/interaction suggestions
+
+Focus on the user experience. Call out any usability concerns or improvements.`,
+
+  'qa': `You are working this ticket as QA. Provide:
+1. Test scenarios (happy path + edge cases)
+2. Acceptance criteria checklist
+3. Potential regression areas
+4. Edge cases and boundary conditions to verify
+
+Be thorough. Think about what could break and how to verify it works.`,
+}
+
+const FALLBACK_PROMPT = `You are working this ticket. Provide:
+1. Analysis of what needs to be done
+2. Recommended approach
+3. Key considerations or risks
+4. Next steps
+
+Be concise and actionable.`
+
+export function getWorkPrompt(ticket: KanbanTicket): string {
+  const rolePrompt = ticket.assigneeRole
+    ? ROLE_PROMPTS[ticket.assigneeRole] ?? FALLBACK_PROMPT
+    : FALLBACK_PROMPT
+
+  return `${rolePrompt}
+
+Ticket: ${ticket.title}
+${ticket.description ? `Description: ${ticket.description}` : 'No description provided.'}
+Priority: ${ticket.priority}`
+}
+
+/* ── Execute work via chat API ───────────────────────── */
+
+interface WorkResult {
+  success: boolean
+  content: string
+  error?: string
+}
+
+export async function executeWork(
+  agentId: string,
+  ticket: KanbanTicket,
+  onChunk?: (chunk: string) => void,
+): Promise<WorkResult> {
+  const prompt = getWorkPrompt(ticket)
+
+  try {
+    const res = await fetch(`/api/kanban/chat/${agentId}`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({
+        messages: [{ role: 'user', content: prompt }],
+        ticket: {
+          title: ticket.title,
+          description: ticket.description,
+          status: ticket.status,
+          priority: ticket.priority,
+          assigneeRole: ticket.assigneeRole,
+        },
+      }),
+    })
+
+    if (!res.ok || !res.body) {
+      return { success: false, content: '', error: `API error: ${res.status}` }
+    }
+
+    const reader = res.body.getReader()
+    const decoder = new TextDecoder()
+    let buffer = ''
+    let fullContent = ''
+
+    while (true) {
+      const { done, value } = await reader.read()
+      if (done) break
+
+      buffer += decoder.decode(value, { stream: true })
+      const lines = buffer.split('\n')
+      buffer = lines.pop() || ''
+
+      for (const line of lines) {
+        if (line.startsWith('data: ') && line !== 'data: [DONE]') {
+          try {
+            const chunk = JSON.parse(line.slice(6))
+            if (chunk.content) {
+              fullContent += chunk.content
+              onChunk?.(chunk.content)
+            }
+          } catch { /* skip malformed chunks */ }
+        }
+      }
+    }
+
+    if (!fullContent) {
+      return { success: false, content: '', error: 'Empty response from agent' }
+    }
+
+    return { success: true, content: fullContent }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : 'Unknown error'
+    return { success: false, content: '', error: message }
+  }
+}
+
+/* ── Persist work chat to filesystem via API ─────────── */
+
+export function persistWorkChat(
+  ticketId: string,
+  prompt: string,
+  response: string,
+): void {
+  const now = Date.now()
+  const messages = [
+    { id: crypto.randomUUID(), role: 'user' as const, content: prompt, timestamp: now },
+    { id: crypto.randomUUID(), role: 'assistant' as const, content: response, timestamp: now + 1 },
+  ]
+
+  fetch(`/api/kanban/chat-history/${ticketId}`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ messages }),
+  }).catch(() => { /* persist best-effort */ })
+}

package/lib/kanban/chat-store.test.ts

@@ -0,0 +1,149 @@
+// @vitest-environment node
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+
+const { mockReadFileSync, mockAppendFileSync, mockMkdirSync, mockExistsSync } = vi.hoisted(() => ({
+  mockReadFileSync: vi.fn(),
+  mockAppendFileSync: vi.fn(),
+  mockMkdirSync: vi.fn(),
+  mockExistsSync: vi.fn(),
+}))
+
+vi.mock('fs', () => ({
+  readFileSync: mockReadFileSync,
+  appendFileSync: mockAppendFileSync,
+  mkdirSync: mockMkdirSync,
+  existsSync: mockExistsSync,
+  default: {
+    readFileSync: mockReadFileSync,
+    appendFileSync: mockAppendFileSync,
+    mkdirSync: mockMkdirSync,
+    existsSync: mockExistsSync,
+  },
+}))
+
+import { getChatMessages, appendChatMessages, StoredChatMessage } from './chat-store'
+
+beforeEach(() => {
+  vi.clearAllMocks()
+  vi.stubEnv('WORKSPACE_PATH', '/tmp/test-workspace')
+  mockExistsSync.mockReturnValue(true)
+})
+
+describe('getChatMessages', () => {
+  it('parses JSONL lines and returns sorted oldest-first', () => {
+    const lines = [
+      JSON.stringify({ id: 'c', role: 'assistant', content: 'last', timestamp: 3000 }),
+      JSON.stringify({ id: 'a', role: 'user', content: 'first', timestamp: 1000 }),
+      JSON.stringify({ id: 'b', role: 'assistant', content: 'second', timestamp: 2000 }),
+    ].join('\n')
+
+    mockReadFileSync.mockReturnValue(lines)
+
+    const messages = getChatMessages('ticket-1')
+    expect(messages).toHaveLength(3)
+    expect(messages[0].id).toBe('a')
+    expect(messages[0].timestamp).toBe(1000)
+    expect(messages[1].id).toBe('b')
+    expect(messages[2].id).toBe('c')
+  })
+
+  it('returns empty array when file does not exist', () => {
+    mockExistsSync.mockReturnValue(false)
+    const messages = getChatMessages('missing-ticket')
+    expect(messages).toEqual([])
+    expect(mockReadFileSync).not.toHaveBeenCalled()
+  })
+
+  it('returns empty array when file is empty', () => {
+    mockReadFileSync.mockReturnValue('')
+    const messages = getChatMessages('empty-ticket')
+    expect(messages).toEqual([])
+  })
+
+  it('skips malformed JSON lines', () => {
+    const lines = [
+      'not valid json',
+      JSON.stringify({ id: 'a', role: 'user', content: 'hi', timestamp: 1000 }),
+      '{ broken',
+      '',
+    ].join('\n')
+
+    mockReadFileSync.mockReturnValue(lines)
+
+    const messages = getChatMessages('ticket-1')
+    expect(messages).toHaveLength(1)
+    expect(messages[0].id).toBe('a')
+  })
+
+  it('skips lines with missing required fields', () => {
+    const lines = [
+      JSON.stringify({ role: 'user', content: 'no id', timestamp: 1000 }),
+      JSON.stringify({ id: '', role: 'user', content: 'empty id', timestamp: 1000 }),
+      JSON.stringify({ id: 'a', role: 'system', content: 'bad role', timestamp: 1000 }),
+      JSON.stringify({ id: 'b', role: 'user', content: 'valid', timestamp: 2000 }),
+    ].join('\n')
+
+    mockReadFileSync.mockReturnValue(lines)
+
+    const messages = getChatMessages('ticket-1')
+    expect(messages).toHaveLength(1)
+    expect(messages[0].id).toBe('b')
+  })
+
+  it('handles unreadable files gracefully', () => {
+    mockReadFileSync.mockImplementation(() => { throw new Error('permission denied') })
+    const messages = getChatMessages('ticket-1')
+    expect(messages).toEqual([])
+  })
+
+  it('defaults timestamp to 0 for non-numeric values', () => {
+    const lines = JSON.stringify({ id: 'a', role: 'user', content: 'hi', timestamp: 'bad' })
+    mockReadFileSync.mockReturnValue(lines)
+
+    const messages = getChatMessages('ticket-1')
+    expect(messages).toHaveLength(1)
+    expect(messages[0].timestamp).toBe(0)
+  })
+})
+
+describe('appendChatMessages', () => {
+  it('creates directory and appends messages as JSONL', () => {
+    const messages: StoredChatMessage[] = [
+      { id: 'a', role: 'user', content: 'hello', timestamp: 1000 },
+      { id: 'b', role: 'assistant', content: 'hi there', timestamp: 2000 },
+    ]
+
+    appendChatMessages('ticket-1', messages)
+
+    expect(mockMkdirSync).toHaveBeenCalledWith(
+      expect.stringContaining('kanban/chats'),
+      { recursive: true },
+    )
+
+    const written = mockAppendFileSync.mock.calls[0][1] as string
+    const lines = written.trim().split('\n')
+    expect(lines).toHaveLength(2)
+    expect(JSON.parse(lines[0])).toEqual({ id: 'a', role: 'user', content: 'hello', timestamp: 1000 })
+    expect(JSON.parse(lines[1])).toEqual({ id: 'b', role: 'assistant', content: 'hi there', timestamp: 2000 })
+  })
+
+  it('appends single message correctly', () => {
+    const messages: StoredChatMessage[] = [
+      { id: 'x', role: 'user', content: 'test', timestamp: 5000 },
+    ]
+
+    appendChatMessages('ticket-2', messages)
+
+    const written = mockAppendFileSync.mock.calls[0][1] as string
+    expect(written).toBe('{"id":"x","role":"user","content":"test","timestamp":5000}\n')
+  })
+
+  it('writes to correct file path based on ticketId', () => {
+    appendChatMessages('my-ticket-id', [
+      { id: 'a', role: 'user', content: 'hi', timestamp: 1000 },
+    ])
+
+    const filePath = mockAppendFileSync.mock.calls[0][0] as string
+    expect(filePath).toContain('my-ticket-id.jsonl')
+  })
+})

package/lib/kanban/chat-store.ts

@@ -0,0 +1,81 @@
+import { readFileSync, appendFileSync, mkdirSync, existsSync } from 'fs'
+import path from 'path'
+import { requireEnv } from '@/lib/env'
+
+/** Serializable chat message (no isStreaming — UI-only field) */
+export interface StoredChatMessage {
+  id: string
+  role: 'user' | 'assistant'
+  content: string
+  timestamp: number
+}
+
+/** Derive the chats directory from WORKSPACE_PATH */
+function getChatsDir(): string {
+  return path.resolve(requireEnv('WORKSPACE_PATH'), '..', 'kanban', 'chats')
+}
+
+/**
+ * Parse a single JSONL line into a StoredChatMessage.
+ * Returns null if the line can't be parsed or is missing required fields.
+ */
+function parseLine(line: string): StoredChatMessage | null {
+  if (!line.trim()) return null
+  try {
+    const obj = JSON.parse(line)
+    if (typeof obj.id !== 'string' || !obj.id) return null
+    if (obj.role !== 'user' && obj.role !== 'assistant') return null
+    if (typeof obj.content !== 'string') return null
+    return {
+      id: obj.id,
+      role: obj.role,
+      content: obj.content,
+      timestamp: typeof obj.timestamp === 'number' ? obj.timestamp : 0,
+    }
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Read chat messages for a ticket from its JSONL file.
+ * Returns StoredChatMessage[] sorted oldest-first by timestamp.
+ */
+export function getChatMessages(ticketId: string): StoredChatMessage[] {
+  const chatsDir = getChatsDir()
+  const filePath = path.join(chatsDir, `${ticketId}.jsonl`)
+
+  if (!existsSync(filePath)) return []
+
+  try {
+    const content = readFileSync(filePath, 'utf-8')
+    const messages: StoredChatMessage[] = []
+    for (const line of content.split('\n')) {
+      const msg = parseLine(line)
+      if (msg) messages.push(msg)
+    }
+    messages.sort((a, b) => a.timestamp - b.timestamp)
+    return messages
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Append chat messages to a ticket's JSONL file.
+ * Creates the chats directory and file if they don't exist.
+ */
+export function appendChatMessages(ticketId: string, messages: StoredChatMessage[]): void {
+  const chatsDir = getChatsDir()
+  mkdirSync(chatsDir, { recursive: true })
+
+  const filePath = path.join(chatsDir, `${ticketId}.jsonl`)
+  const lines = messages.map(m => JSON.stringify({
+    id: m.id,
+    role: m.role,
+    content: m.content,
+    timestamp: m.timestamp,
+  }))
+
+  appendFileSync(filePath, lines.join('\n') + '\n', 'utf-8')
+}