popilot 0.6.0 → 0.8.0

package/scaffold/spec-site/src/composables/pmTypes.ts

@@ -4,7 +4,7 @@
 
 // ── Domain types ──
 
-export type StoryStatus = 'draft' | 'backlog' | 'ready' | 'in-progress' | 'review' | 'done'
+export type StoryStatus = 'draft' | 'backlog' | 'ready' | 'in-progress' | 'review' | 'qa' | 'done'
 export type TaskStatus = 'todo' | 'in-progress' | 'done'
 export type Priority = 'low' | 'medium' | 'high' | 'critical'
 export type EpicStatus = 'active' | 'completed' | 'archived'
@@ -31,6 +31,10 @@ export interface PmStory {
   priority: Priority
   area: string
   storyPoints: number | null
+  startDate: string | null
+  dueDate: string | null
+  figmaUrl: string | null
+  relatedPrs: Array<{ prNumber: number; prUrl: string; prTitle: string; status: string }>
   sortOrder: number
   createdAt: string
   updatedAt: string
@@ -43,6 +47,8 @@ export interface PmTask {
   assignee: string | null
   status: TaskStatus
   description: string | null
+  storyPoints: number | null
+  dueDate: string | null
   sortOrder: number
   createdAt: string
   updatedAt: string
@@ -77,6 +83,10 @@ export function mapStory(r: PmStoryRow): PmStory {
     priority: (r.priority ?? 'medium') as Priority,
     area: r.area ?? 'FE',
     storyPoints: r.story_points,
+    startDate: r.start_date ?? null,
+    dueDate: r.due_date ?? null,
+    figmaUrl: r.figma_url ?? null,
+    relatedPrs: r.related_prs ? JSON.parse(r.related_prs) : [],
     sortOrder: r.sort_order,
     createdAt: r.created_at,
     updatedAt: r.updated_at,
@@ -91,6 +101,8 @@ export function mapTask(r: PmTaskRow): PmTask {
     assignee: r.assignee,
     status: r.status as TaskStatus,
     description: r.description,
+    storyPoints: r.story_points ?? null,
+    dueDate: r.due_date ?? null,
     sortOrder: r.sort_order,
     createdAt: r.created_at,
     updatedAt: r.updated_at,
@@ -99,7 +111,7 @@ export function mapTask(r: PmTaskRow): PmTask {
 
 // ── Status constants ──
 
-export const STORY_STATUSES: StoryStatus[] = ['draft', 'backlog', 'ready', 'in-progress', 'review', 'done']
+export const STORY_STATUSES: StoryStatus[] = ['draft', 'backlog', 'ready', 'in-progress', 'review', 'qa', 'done']
 export const TASK_STATUSES: TaskStatus[] = ['todo', 'in-progress', 'done']
 export const PRIORITIES: Priority[] = ['low', 'medium', 'high', 'critical']
 export const AREAS = ['FE', 'BE', 'Design', 'Data', 'Infra', 'PO'] as const
@@ -111,6 +123,7 @@ export const STORY_STATUS_LABELS: Record<StoryStatus, string> = {
   'ready': 'Ready',
   'in-progress': 'In Progress',
   'review': 'Review',
+  'qa': 'QA',
   'done': 'Done',
 }
 

package/scaffold/spec-site/src/composables/useBottomSheet.ts

@@ -0,0 +1,103 @@
+import { ref, computed, type Ref } from 'vue'
+
+export type SheetState = 'peek' | 'half' | 'full'
+
+const PEEK_HEIGHT = 48
+const HALF_RATIO = 0.5
+const FULL_RATIO = 0.85
+const VELOCITY_THRESHOLD = 0.5 // px/ms
+
+export function useBottomSheet() {
+  const state: Ref<SheetState> = ref('peek')
+  const dragging = ref(false)
+  const dragOffset = ref(0)
+
+  let startY = 0
+  let startTime = 0
+  let startTranslateY = 0
+
+  function getTranslateY(s: SheetState): number {
+    const vh = window.innerHeight
+    const sheetHeight = vh * FULL_RATIO
+    switch (s) {
+      case 'peek': return sheetHeight - PEEK_HEIGHT
+      case 'half': return sheetHeight - vh * HALF_RATIO
+      case 'full': return 0
+    }
+  }
+
+  const translateY = computed(() => {
+    const base = getTranslateY(state.value)
+    return dragging.value ? base + dragOffset.value : base
+  })
+
+  function tap() {
+    const order: SheetState[] = ['peek', 'half', 'full']
+    const idx = order.indexOf(state.value)
+    state.value = order[(idx + 1) % order.length]
+  }
+
+  function onPointerDown(e: PointerEvent) {
+    dragging.value = true
+    dragOffset.value = 0
+    startY = e.clientY
+    startTime = Date.now()
+    startTranslateY = getTranslateY(state.value)
+    ;(e.target as HTMLElement).setPointerCapture(e.pointerId)
+  }
+
+  function onPointerMove(e: PointerEvent) {
+    if (!dragging.value) return
+    const dy = e.clientY - startY
+    const sheetHeight = window.innerHeight * FULL_RATIO
+    dragOffset.value = Math.max(-startTranslateY, Math.min(dy, sheetHeight - PEEK_HEIGHT - startTranslateY))
+  }
+
+  function onPointerUp(e: PointerEvent) {
+    if (!dragging.value) return
+    dragging.value = false
+
+    const dy = e.clientY - startY
+    const dt = Date.now() - startTime
+    const velocity = dy / Math.max(dt, 1)
+
+    if (Math.abs(velocity) > VELOCITY_THRESHOLD) {
+      if (velocity > 0) {
+        state.value = state.value === 'full' ? 'half' : 'peek'
+      } else {
+        state.value = state.value === 'peek' ? 'half' : 'full'
+      }
+    } else {
+      const currentTranslate = startTranslateY + dragOffset.value
+      const sheetHeight = window.innerHeight * FULL_RATIO
+      const peekT = sheetHeight - PEEK_HEIGHT
+      const halfT = sheetHeight - window.innerHeight * HALF_RATIO
+      const fullT = 0
+
+      const distances = [
+        { state: 'peek' as SheetState, d: Math.abs(currentTranslate - peekT) },
+        { state: 'half' as SheetState, d: Math.abs(currentTranslate - halfT) },
+        { state: 'full' as SheetState, d: Math.abs(currentTranslate - fullT) },
+      ]
+      distances.sort((a, b) => a.d - b.d)
+      state.value = distances[0].state
+    }
+
+    dragOffset.value = 0
+  }
+
+  function setState(s: SheetState) {
+    state.value = s
+  }
+
+  return {
+    state,
+    dragging,
+    translateY,
+    tap,
+    setState,
+    onPointerDown,
+    onPointerMove,
+    onPointerUp,
+  }
+}

package/scaffold/spec-site/src/composables/useDashboard.ts

@@ -0,0 +1,221 @@
+/**
+ * Dashboard composable — aggregates data from multiple dashboard APIs.
+ *
+ * In static mode, returns empty state gracefully.
+ */
+import { ref } from 'vue'
+import { apiGet, isStaticMode } from '@/api/client'
+
+export interface UnreadMemo {
+  id: number
+  content: string
+  memoType: string
+  createdBy: string
+  createdAt: string
+  reviewRequired: number
+  pageId: string
+  replyCount: number
+  title: string | null
+  supersedesId: number | null
+}
+
+export interface SprintProgress {
+  sprint: string
+  total: number
+  done: number
+  progressPercent: number
+  byStatus: Record<string, number>
+}
+
+export interface StandupStatus {
+  date: string
+  written: string[]
+  count: number
+}
+
+export interface MyRequest {
+  id: number
+  title: string | null
+  content: string
+  memoType: string
+  assignedTo: string | null
+  status: string
+  createdAt: string
+  supersedesId: number | null
+}
+
+export interface Decision {
+  id: number
+  title: string | null
+  content: string
+  createdBy: string
+  assignedTo: string | null
+  createdAt: string
+  supersedesId: number | null
+}
+
+export interface NudgeLogItem {
+  id: number
+  ruleId: string
+  title: string
+  body: string
+  createdAt: string
+}
+
+export interface TeamInitiative {
+  id: number
+  title: string | null
+  content: string
+  memoType: string
+  createdBy: string
+  createdAt: string
+}
+
+export function useDashboard() {
+  const unreadMemos = ref<UnreadMemo[]>([])
+  const pendingReviews = ref<UnreadMemo[]>([])
+  const myRequests = ref<MyRequest[]>([])
+  const activeDecisions = ref<Decision[]>([])
+  const sprintProgress = ref<SprintProgress | null>(null)
+  const mySprintProgress = ref<SprintProgress | null>(null)
+  const standupStatus = ref<StandupStatus | null>(null)
+  const loading = ref(false)
+  const errors = ref<string[]>([])
+  const nudgeLog = ref<NudgeLogItem[]>([])
+  const teamInitiatives = ref<TeamInitiative[]>([])
+
+  function todayStr(): string {
+    return new Date().toISOString().split('T')[0]
+  }
+
+  async function loadAll(sprint: string, userName?: string) {
+    if (isStaticMode()) { loading.value = false; return }
+    loading.value = true
+    errors.value = []
+
+    const fetches = [
+      apiGet<{ unreadMemos: Array<Record<string, unknown>> }>('/api/v2/dashboard/unread-memos'),
+      apiGet<{ unreadMemos: Array<Record<string, unknown>> }>('/api/v2/dashboard/unread-memos', { review_required: '1' }),
+      apiGet<{ sprint: string; total: number; done: number; progressPercent: number; byStatus: Record<string, number> }>('/api/v2/dashboard/sprint-progress', { sprint }),
+      apiGet<{ date: string; written: string[]; count: number }>('/api/v2/dashboard/standup-status', { sprint, date: todayStr() }),
+      apiGet<{ myRequests: Array<Record<string, unknown>> }>('/api/v2/dashboard/my-requests'),
+      apiGet<{ decisions: Array<Record<string, unknown>> }>('/api/v2/dashboard/active-decisions'),
+    ]
+
+    if (userName) {
+      fetches.push(
+        apiGet<SprintProgress>('/api/v2/dashboard/sprint-progress', { sprint, user: userName }),
+      )
+    }
+
+    const results = await Promise.all(fetches)
+
+    if (results[0].error) errors.value.push(results[0].error)
+    else if (results[0].data) unreadMemos.value = ((results[0].data as any).unreadMemos ?? []).map(mapMemo)
+
+    if (results[1].error) errors.value.push(results[1].error)
+    else if (results[1].data) pendingReviews.value = ((results[1].data as any).unreadMemos ?? []).map(mapMemo)
+
+    if (results[2].error) errors.value.push(results[2].error)
+    else if (results[2].data) sprintProgress.value = results[2].data as SprintProgress
+
+    if (results[3].error) errors.value.push(results[3].error)
+    else if (results[3].data) standupStatus.value = results[3].data as StandupStatus
+
+    if (results[4].error) errors.value.push(results[4].error)
+    else if (results[4].data) myRequests.value = ((results[4].data as any).myRequests ?? []).map(mapRequest)
+
+    if (results[5].error) errors.value.push(results[5].error)
+    else if (results[5].data) activeDecisions.value = ((results[5].data as any).decisions ?? []).map(mapDecision)
+
+    if (userName && results[6]) {
+      if (results[6].error) errors.value.push(results[6].error)
+      else if (results[6].data) mySprintProgress.value = results[6].data as SprintProgress
+    }
+
+    loading.value = false
+  }
+
+  async function loadNudgeLog() {
+    if (isStaticMode()) return
+    const { data } = await apiGet<{ nudges: Array<Record<string, unknown>> }>(
+      '/api/v2/dashboard/nudge-log', { limit: '10' },
+    )
+    if (data?.nudges) {
+      nudgeLog.value = (data.nudges as Array<Record<string, unknown>>).map(r => ({
+        id: r.id as number,
+        ruleId: (r.rule_id as string) ?? '',
+        title: (r.title as string) ?? '',
+        body: (r.body as string) ?? '',
+        createdAt: (r.created_at as string) ?? '',
+      }))
+    }
+  }
+
+  async function loadTeamInitiatives() {
+    if (isStaticMode()) return
+    const { data } = await apiGet<{ initiatives: Array<Record<string, unknown>> }>(
+      '/api/v2/initiatives', { limit: '20' },
+    )
+    if (data?.initiatives) {
+      teamInitiatives.value = (data.initiatives as Array<Record<string, unknown>>).map(r => ({
+        id: r.id as number,
+        title: (r.title as string) ?? null,
+        content: (r.content as string) ?? '',
+        memoType: (r.status as string) ?? 'pending',
+        createdBy: (r.author as string) ?? '',
+        createdAt: (r.created_at as string) ?? '',
+      }))
+    } else {
+      // Fallback: memo-based (when initiatives table is unavailable)
+      const { data: memoData } = await apiGet<{ memos: Array<Record<string, unknown>> }>(
+        '/api/v2/memos/all', { limit: '10', status: 'open' },
+      )
+      if (memoData?.memos) {
+        teamInitiatives.value = (memoData.memos as Array<Record<string, unknown>>)
+          .filter(r => r.memo_type === 'feature_request')
+          .map(r => ({
+            id: r.id as number,
+            title: (r.title as string) ?? null,
+            content: (r.content as string) ?? '',
+            memoType: (r.memo_type as string) ?? '',
+            createdBy: (r.created_by as string) ?? '',
+            createdAt: (r.created_at as string) ?? '',
+          }))
+      }
+    }
+  }
+
+  return {
+    unreadMemos, pendingReviews, myRequests, activeDecisions,
+    sprintProgress, mySprintProgress, standupStatus, nudgeLog, teamInitiatives,
+    loading, errors, loadAll, loadNudgeLog, loadTeamInitiatives,
+  }
+}
+
+function mapMemo(r: Record<string, unknown>): UnreadMemo {
+  return {
+    id: r.id as number, content: (r.content as string) ?? '', memoType: (r.memo_type as string) ?? 'memo',
+    createdBy: (r.created_by as string) ?? '', createdAt: (r.created_at as string) ?? '',
+    reviewRequired: (r.review_required as number) ?? 0, pageId: (r.page_id as string) ?? '',
+    replyCount: (r.reply_count as number) ?? 0, title: (r.title as string) ?? null,
+    supersedesId: (r.supersedes_id as number) ?? null,
+  }
+}
+
+function mapRequest(r: Record<string, unknown>): MyRequest {
+  return {
+    id: r.id as number, title: (r.title as string) ?? null, content: (r.content as string) ?? '',
+    memoType: (r.memo_type as string) ?? '', assignedTo: (r.assigned_to as string) ?? null,
+    status: (r.status as string) ?? 'open', createdAt: (r.created_at as string) ?? '',
+    supersedesId: (r.supersedes_id as number) ?? null,
+  }
+}
+
+function mapDecision(r: Record<string, unknown>): Decision {
+  return {
+    id: r.id as number, title: (r.title as string) ?? null, content: (r.content as string) ?? '',
+    createdBy: (r.created_by as string) ?? '', assignedTo: (r.assigned_to as string) ?? null,
+    createdAt: (r.created_at as string) ?? '', supersedesId: (r.supersedes_id as number) ?? null,
+  }
+}

package/scaffold/spec-site/src/composables/useMediaQuery.ts

@@ -0,0 +1,28 @@
+/**
+ * Media query composable — generic reactive media query wrapper.
+ *
+ * Usage: const isMobile = useMediaQuery('(max-width: 767px)')
+ */
+
+import { ref, onMounted, onUnmounted, type Ref } from 'vue'
+
+export function useMediaQuery(query: string): Ref<boolean> {
+  const matches = ref(false)
+  let mql: MediaQueryList | null = null
+
+  function update(e: MediaQueryListEvent | MediaQueryList) {
+    matches.value = e.matches
+  }
+
+  onMounted(() => {
+    mql = window.matchMedia(query)
+    matches.value = mql.matches
+    mql.addEventListener('change', update)
+  })
+
+  onUnmounted(() => {
+    mql?.removeEventListener('change', update)
+  })
+
+  return matches
+}

package/scaffold/spec-site/src/composables/useMemo.ts

@@ -8,11 +8,50 @@
 import { ref, computed } from 'vue'
 import { isStaticMode } from '@/api/client'
 
+// ── Tier 1 (simple, localStorage-backed) ──
 export interface MemoItem {
   id: number
   text: string
   author: string
   ts: number
+  // Tier 2 extended fields (API-backed)
+  page_id?: string
+  content?: string
+  memo_type?: MemoType
+  status?: 'open' | 'resolved'
+  created_by?: string
+  assigned_to?: string | null
+  review_required?: number
+  title?: string | null
+  channel?: string
+  resolved_by?: string | null
+  resolved_at?: string | null
+  created_at?: string
+  updated_at?: string
+  checklist?: string | null
+  reply_count?: number
+  has_relations?: number
+}
+
+export type MemoType = 'memo' | 'decision' | 'request' | 'backlog' | 'blocker' | 'question' | 'announcement'
+
+export const MEMO_TYPES: { value: MemoType; label: string; icon: string; color: string }[] = [
+  { value: 'memo', label: 'Memo', icon: '📝', color: '#3b82f6' },
+  { value: 'decision', label: 'Decision', icon: '⚡', color: '#8b5cf6' },
+  { value: 'request', label: 'Request', icon: '📋', color: '#f59e0b' },
+  { value: 'backlog', label: 'Backlog', icon: '💡', color: '#22c55e' },
+  { value: 'blocker', label: 'Blocker', icon: '🚧', color: '#ef4444' },
+  { value: 'question', label: 'Question', icon: '❓', color: '#06b6d4' },
+  { value: 'announcement', label: 'Announcement', icon: '📢', color: '#6366f1' },
+]
+
+export interface ReplyItem {
+  id: number
+  memo_id: number
+  content: string
+  created_by: string
+  review_type?: string
+  created_at: string
 }
 
 export function useMemo(pageId: string) {

package/scaffold/spec-site/src/composables/useNotification.ts

@@ -0,0 +1,200 @@
+/**
+ * Notification composable — fetch, poll, and manage notifications.
+ *
+ * Singleton pattern: refs are module-level, shared across all consumers.
+ * In static mode, returns empty state gracefully.
+ */
+
+import { ref, computed } from 'vue'
+import { apiGet, apiPost, apiPatch, apiDelete, isStaticMode } from '@/api/client'
+
+export interface NotificationItem {
+  id: number
+  type: string
+  title: string
+  body: string | null
+  sourceType: string
+  sourceId: number
+  pageId: string
+  actor: string
+  isRead: boolean
+  createdAt: number
+}
+
+// Module-level singletons
+const notifications = ref<NotificationItem[]>([])
+const _userName = ref<string | null>(null)
+let _pollTimer: ReturnType<typeof setInterval> | null = null
+
+// Cross-component communication: notification click -> open memo sidebar
+export const shouldOpenMemoSidebar = ref(false)
+export const pendingNotificationPageId = ref<string | null>(null)
+
+export function useNotification() {
+  const unreadCount = computed(() => notifications.value.filter(n => !n.isRead).length)
+
+  function setUser(name: string | null) {
+    _userName.value = name
+    if (name) {
+      fetchNotifications()
+    } else {
+      notifications.value = []
+    }
+  }
+
+  async function fetchNotifications(): Promise<void> {
+    if (isStaticMode() || !_userName.value) return
+    try {
+      const { data } = await apiGet<{
+        notifications: Array<{
+          id: number; type: string; title: string; body: string | null
+          source_type: string; source_id: number; page_id: string
+          actor: string; is_read: number; created_at: string
+        }>
+      }>('/api/v2/notifications', { user: _userName.value })
+      if (data) {
+        notifications.value = data.notifications.map(row => ({
+          id: Number(row.id),
+          type: String(row.type),
+          title: String(row.title),
+          body: row.body ? String(row.body) : null,
+          sourceType: String(row.source_type),
+          sourceId: Number(row.source_id),
+          pageId: String(row.page_id),
+          actor: String(row.actor),
+          isRead: Number(row.is_read) === 1,
+          createdAt: new Date(row.created_at + 'Z').getTime(),
+        }))
+      }
+    } catch {
+      // offline -- keep existing
+    }
+  }
+
+  async function markAsRead(id: number): Promise<void> {
+    if (isStaticMode()) return
+    try {
+      const { error } = await apiPatch(`/api/v2/notifications/${id}/read`, {})
+      if (!error) {
+        const item = notifications.value.find(n => n.id === id)
+        if (item) item.isRead = true
+      }
+    } catch { /* ignore */ }
+  }
+
+  async function markAllAsRead(): Promise<void> {
+    if (isStaticMode() || !_userName.value) return
+    try {
+      const { error } = await apiPost('/api/v2/notifications/mark-all-read', { user: _userName.value })
+      if (!error) {
+        notifications.value.forEach(n => { n.isRead = true })
+      } else {
+        await fetchNotifications()
+      }
+    } catch { /* ignore */ }
+  }
+
+  function startPolling() {
+    stopPolling()
+    _pollTimer = setInterval(() => fetchNotifications(), 30_000)
+  }
+
+  function stopPolling() {
+    if (_pollTimer) {
+      clearInterval(_pollTimer)
+      _pollTimer = null
+    }
+  }
+
+  // Notification creation (called from useMemo)
+
+  async function createMemoNotifications(
+    memoId: number,
+    pageId: string,
+    author: string,
+    assignedTo: string | null,
+    content: string,
+  ): Promise<void> {
+    if (isStaticMode()) return
+    const preview = content.length > 60 ? content.slice(0, 60) + '...' : content
+
+    if (assignedTo) {
+      await _insertNotification(assignedTo, 'memo_assigned', `${author} left a memo`, preview, 'memo', memoId, pageId, author)
+    } else {
+      const members = await _getActiveMembers()
+      for (const m of members) {
+        if (m === author) continue
+        await _insertNotification(m, 'memo_mention_all', `${author} left a team memo`, preview, 'memo', memoId, pageId, author)
+      }
+    }
+  }
+
+  async function createReplyNotification(
+    memoId: number,
+    pageId: string,
+    replier: string,
+    memoAuthor: string,
+    content: string,
+  ): Promise<void> {
+    if (isStaticMode()) return
+    if (replier === memoAuthor) return
+    const preview = content.length > 60 ? content.slice(0, 60) + '...' : content
+    await _insertNotification(memoAuthor, 'reply_received', `${replier} replied`, preview, 'memo', memoId, pageId, replier)
+  }
+
+  async function deleteNotificationsForMemo(memoId: number): Promise<void> {
+    if (isStaticMode()) return
+    try {
+      await apiDelete('/api/v2/notifications/by-source', { sourceType: 'memo', sourceId: memoId })
+    } catch { /* ignore */ }
+  }
+
+  // Internal helpers
+
+  async function _insertNotification(
+    userName: string, type: string, title: string, body: string | null,
+    sourceType: string, sourceId: number, pageId: string, actor: string,
+  ): Promise<void> {
+    try {
+      await apiPost('/api/v2/notifications', {
+        userName, type, title, body, sourceType, sourceId, pageId, actor,
+      })
+    } catch { /* ignore */ }
+  }
+
+  async function _getActiveMembers(): Promise<string[]> {
+    try {
+      const { data } = await apiGet<{ users: string[] }>('/api/v2/notifications/active-users')
+      if (data) return data.users
+    } catch { /* ignore */ }
+    return []
+  }
+
+  function formatTimeAgo(ts: number): string {
+    const diff = Date.now() - ts
+    const mins = Math.floor(diff / 60_000)
+    if (mins < 1) return 'just now'
+    if (mins < 60) return `${mins}min ago`
+    const hours = Math.floor(mins / 60)
+    if (hours < 24) return `${hours}hr ago`
+    const days = Math.floor(hours / 24)
+    return `${days}d ago`
+  }
+
+  return {
+    notifications,
+    unreadCount,
+    setUser,
+    fetchNotifications,
+    markAsRead,
+    markAllAsRead,
+    startPolling,
+    stopPolling,
+    createMemoNotifications,
+    createReplyNotification,
+    deleteNotificationsForMemo,
+    formatTimeAgo,
+    shouldOpenMemoSidebar,
+    pendingNotificationPageId,
+  }
+}