popilot 0.5.0 → 0.7.0

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,
+  }
+}

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

@@ -142,7 +142,8 @@ export async function updateStory(id: number, data: {
   area?: string
   storyPoints?: number | null
   epicId?: number | null
-  sprint?: string
+  sprint?: string | null
+  figmaUrl?: string | null
 }): Promise<{ error?: string }> {
   if (isStaticMode()) return { error: 'CRUD not available in static mode' }
   const { error } = await apiPatch(`/api/v2/pm/stories/${id}`, data as Record<string, unknown>)
@@ -222,3 +223,49 @@ export function getEpicById(id: number): PmEpic | undefined {
 export function getTasksForStory(storyId: number): PmTask[] {
   return tasks.value.filter(t => t.storyId === storyId)
 }
+
+export function getBacklogStories(): PmStory[] {
+  return stories.value.filter(s => s.status === 'backlog')
+}
+
+export function getMyStories(user: string): PmStory[] {
+  return stories.value.filter(s => s.assignee === user)
+}
+
+export function getMyTasks(user: string): PmTask[] {
+  return tasks.value.filter(t => t.assignee === user)
+}
+
+export async function updateStoryStatus(id: number, status: StoryStatus): Promise<{ error?: string }> {
+  return updateStory(id, { status })
+}
+
+export async function updateTaskStatus(id: number, status: TaskStatus): Promise<{ error?: string }> {
+  return updateTask(id, { status })
+}
+
+export async function moveToSprint(storyId: number, sprint: string | null): Promise<{ error?: string }> {
+  return updateStory(storyId, { sprint })
+}
+
+export async function loadBacklog(): Promise<void> {
+  if (isStaticMode()) return
+  const { data, error } = await apiGet<{ stories: PmStoryRow[]; tasks: PmTaskRow[] }>(
+    '/api/v2/pm/data', { status: 'backlog' },
+  )
+  if (!error && data) {
+    // Merge backlog stories into existing list (avoid duplicates)
+    const existingIds = new Set(stories.value.map(s => s.id))
+    for (const row of data.stories) {
+      if (!existingIds.has(row.id)) {
+        stories.value.push(mapStory(row))
+      }
+    }
+    const existingTaskIds = new Set(tasks.value.map(t => t.id))
+    for (const row of data.tasks) {
+      if (!existingTaskIds.has(row.id)) {
+        tasks.value.push(mapTask(row))
+      }
+    }
+  }
+}

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

@@ -372,6 +372,11 @@ export function useRetro(sprintId: string) {
 
   onUnmounted(stopPolling)
 
+  const participants = computed(() => {
+    const authors = new Set(items.value.map(i => i.author))
+    return Array.from(authors).sort()
+  })
+
   return {
     session,
     items,
@@ -383,6 +388,7 @@ export function useRetro(sprintId: string) {
     tryItems,
     myVoteCount,
     votesRemaining,
+    participants,
     loadOrCreateSession,
     setPhase,
     addItem,

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

@@ -0,0 +1,201 @@
+/**
+ * Standup composable — fetch and save daily standup entries.
+ *
+ * Singleton pattern for team entries; instance pattern for polling.
+ * In static mode, returns empty state gracefully.
+ */
+
+import { ref, onUnmounted } from 'vue'
+import { apiGet, apiPut, apiPost, isStaticMode } from '@/api/client'
+
+export interface StandupEntry {
+  id: number
+  sprint: string
+  userName: string
+  entryDate: string
+  doneText: string | null
+  planText: string | null
+  planStoryIds: number[]
+  blockers: string | null
+  createdAt: string
+  updatedAt: string
+}
+
+interface StandupRow {
+  id: number
+  sprint: string
+  user_name: string
+  entry_date: string
+  done_text: string | null
+  plan_text: string | null
+  plan_story_ids: string | null
+  blockers: string | null
+  created_at: string
+  updated_at: string
+}
+
+export interface StandupFeedback {
+  id: number
+  standupEntryId: number
+  sprint: string
+  targetUser: string
+  feedbackBy: string
+  feedbackText: string
+  reviewType: 'comment' | 'approve' | 'request_changes'
+  createdAt: string
+}
+
+interface StandupFeedbackRow {
+  id: number
+  standup_entry_id: number
+  sprint: string
+  target_user: string
+  feedback_by: string
+  feedback_text: string
+  review_type: string
+  created_at: string
+}
+
+function mapEntry(r: StandupRow): StandupEntry {
+  return {
+    id: r.id,
+    sprint: r.sprint,
+    userName: r.user_name,
+    entryDate: r.entry_date,
+    doneText: r.done_text,
+    planText: r.plan_text,
+    planStoryIds: r.plan_story_ids ? JSON.parse(r.plan_story_ids) : [],
+    blockers: r.blockers,
+    createdAt: r.created_at,
+    updatedAt: r.updated_at,
+  }
+}
+
+function mapFeedback(r: StandupFeedbackRow): StandupFeedback {
+  return {
+    id: r.id,
+    standupEntryId: r.standup_entry_id,
+    sprint: r.sprint,
+    targetUser: r.target_user,
+    feedbackBy: r.feedback_by,
+    feedbackText: r.feedback_text,
+    reviewType: r.review_type as StandupFeedback['reviewType'],
+    createdAt: r.created_at,
+  }
+}
+
+const POLL_INTERVAL_MS = 30_000
+
+export function useStandup() {
+  const entries = ref<StandupEntry[]>([])
+  const loading = ref(false)
+  const error = ref<string | null>(null)
+
+  async function fetchEntries(date: string): Promise<void> {
+    if (isStaticMode()) return
+    const { data, error: apiError } = await apiGet<{ entries: StandupRow[] }>(
+      '/api/v2/standup/entries', { date },
+    )
+    if (apiError) {
+      error.value = apiError
+    } else if (data) {
+      entries.value = data.entries.map(mapEntry)
+    }
+  }
+
+  async function loadEntries(date: string): Promise<void> {
+    loading.value = true
+    error.value = null
+    await fetchEntries(date)
+    loading.value = false
+  }
+
+  async function saveEntry(
+    userName: string,
+    date: string,
+    sprint: string,
+    data: { doneText?: string | null; planText?: string | null; planStoryIds?: number[]; blockers?: string | null },
+  ): Promise<{ error?: string }> {
+    if (isStaticMode()) return { error: 'Not available in static mode' }
+    const { error: apiError } = await apiPut('/api/v2/standup/entries', {
+      sprint,
+      userName,
+      date,
+      doneText: data.doneText ?? null,
+      planText: data.planText ?? null,
+      planStoryIds: data.planStoryIds ?? null,
+      blockers: data.blockers ?? null,
+    })
+    if (apiError) return { error: apiError }
+    await fetchEntries(date)
+    return {}
+  }
+
+  function getEntryForUser(userName: string, date: string): StandupEntry | undefined {
+    return entries.value.find(e => e.userName === userName && e.entryDate === date)
+  }
+
+  // Polling
+  let pollTimer: ReturnType<typeof setInterval> | null = null
+  let _pollDate = ''
+
+  function startPolling(date: string) {
+    _pollDate = date
+    stopPolling()
+    pollTimer = setInterval(() => fetchEntries(_pollDate), POLL_INTERVAL_MS)
+  }
+
+  function stopPolling() {
+    if (pollTimer) {
+      clearInterval(pollTimer)
+      pollTimer = null
+    }
+  }
+
+  // Feedback
+  const feedback = ref<StandupFeedback[]>([])
+
+  async function loadFeedback(entryId: number): Promise<void> {
+    if (isStaticMode()) return
+    const { data } = await apiGet<{ feedback: StandupFeedbackRow[] }>(
+      '/api/v2/standup/feedback', { standup_entry_id: String(entryId) },
+    )
+    if (data) {
+      feedback.value = data.feedback.map(mapFeedback)
+    }
+  }
+
+  async function submitFeedback(
+    entryId: number, sprint: string, targetUser: string,
+    feedbackBy: string, feedbackText: string, reviewType: string,
+  ): Promise<{ error?: string }> {
+    if (isStaticMode()) return { error: 'Not available in static mode' }
+    const { error: apiError } = await apiPost('/api/v2/standup/feedback', {
+      standupEntryId: entryId,
+      sprint,
+      targetUser,
+      feedbackBy,
+      feedbackText,
+      reviewType,
+    })
+    if (apiError) return { error: apiError }
+    await loadFeedback(entryId)
+    return {}
+  }
+
+  onUnmounted(stopPolling)
+
+  return {
+    entries,
+    loading,
+    error,
+    feedback,
+    loadEntries,
+    saveEntry,
+    getEntryForUser,
+    loadFeedback,
+    submitFeedback,
+    startPolling,
+    stopPolling,
+  }
+}

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

@@ -0,0 +1,37 @@
+/**
+ * Theme composable — light/dark/system theme toggle.
+ *
+ * Applies data-theme attribute to document root.
+ * Persists selection in localStorage.
+ */
+import { ref, watchEffect } from 'vue'
+
+export type ThemeMode = 'light' | 'dark' | 'system'
+
+const theme = ref<ThemeMode>((localStorage.getItem('theme') as ThemeMode) || 'light')
+
+const mediaQuery = window.matchMedia('(prefers-color-scheme: dark)')
+
+function applyTheme() {
+  let effective: 'light' | 'dark'
+  if (theme.value === 'system') {
+    effective = mediaQuery.matches ? 'dark' : 'light'
+  } else {
+    effective = theme.value
+  }
+  document.documentElement.setAttribute('data-theme', effective)
+  localStorage.setItem('theme', theme.value)
+}
+
+mediaQuery.addEventListener('change', applyTheme)
+watchEffect(applyTheme)
+
+export function useTheme() {
+  function toggle() {
+    const order: ThemeMode[] = ['light', 'dark', 'system']
+    const idx = order.indexOf(theme.value)
+    theme.value = order[(idx + 1) % order.length]
+  }
+
+  return { theme, toggle }
+}

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

@@ -6,6 +6,7 @@
  */
 
 import { ref } from 'vue'
+import { apiGet, isStaticMode } from '@/api/client'
 
 // TODO: Replace with your team members or load dynamically from API
 export const TEAM_MEMBERS: string[] = []
@@ -16,6 +17,23 @@ const currentUser = ref<string | null>(
   localStorage.getItem(STORAGE_KEY) ?? null,
 )
 
+const dynamicMembers = ref<string[]>([])
+
+async function loadMembers(): Promise<void> {
+  if (isStaticMode()) {
+    dynamicMembers.value = [...TEAM_MEMBERS]
+    return
+  }
+  try {
+    const { data, error } = await apiGet<{ members: Array<{ name: string }> }>('/api/v2/admin/members')
+    if (!error && data) {
+      dynamicMembers.value = data.members.map(m => m.name)
+    }
+  } catch {
+    dynamicMembers.value = [...TEAM_MEMBERS]
+  }
+}
+
 export function useUser() {
   function setUser(name: string) {
     currentUser.value = name
@@ -27,5 +45,5 @@ export function useUser() {
     localStorage.removeItem(STORAGE_KEY)
   }
 
-  return { currentUser, setUser, clearUser, TEAM_MEMBERS }
+  return { currentUser, setUser, clearUser, TEAM_MEMBERS, dynamicMembers, loadMembers }
 }

package/scaffold/spec-site/src/features.ts

@@ -0,0 +1,108 @@
+/**
+ * Feature flags — resolves enabled features from project config.
+ *
+ * Reads from VITE_FEATURES env variable (comma-separated list)
+ * or defaults to all features enabled in API mode, minimal in static mode.
+ *
+ * Usage:
+ *   import { isFeatureEnabled, enabledFeatures } from '@/features'
+ *   if (isFeatureEnabled('board')) { ... }
+ */
+
+import { isStaticMode } from '@/api/client'
+
+export type FeatureId =
+  | 'dashboard'
+  | 'board'
+  | 'standup'
+  | 'retro'
+  | 'inbox'
+  | 'specs'
+  | 'admin'
+  | 'meetings'
+  | 'docs'
+  | 'my-page'
+  | 'rewards'
+
+/** All available features */
+export const ALL_FEATURES: FeatureId[] = [
+  'dashboard',
+  'board',
+  'standup',
+  'retro',
+  'inbox',
+  'specs',
+  'admin',
+  'meetings',
+  'docs',
+  'my-page',
+  'rewards',
+]
+
+/** Features available in static mode (no backend needed) */
+const STATIC_FEATURES: FeatureId[] = ['specs', 'retro']
+
+/** Features that require API mode */
+const API_ONLY_FEATURES: FeatureId[] = [
+  'dashboard',
+  'board',
+  'standup',
+  'inbox',
+  'admin',
+  'meetings',
+  'docs',
+  'my-page',
+]
+
+function resolveFeatures(): Set<FeatureId> {
+  const envFeatures = import.meta.env.VITE_FEATURES as string | undefined
+
+  if (envFeatures) {
+    // Explicit feature list from env
+    const ids = envFeatures.split(',').map(s => s.trim()) as FeatureId[]
+    return new Set(ids.filter(id => ALL_FEATURES.includes(id)))
+  }
+
+  if (isStaticMode()) {
+    return new Set(STATIC_FEATURES)
+  }
+
+  // API mode: all features enabled by default
+  return new Set(ALL_FEATURES)
+}
+
+const _enabledFeatures = resolveFeatures()
+
+/** Check if a feature is enabled */
+export function isFeatureEnabled(id: FeatureId): boolean {
+  return _enabledFeatures.has(id)
+}
+
+/** Get all enabled features */
+export function enabledFeatures(): FeatureId[] {
+  return ALL_FEATURES.filter(id => _enabledFeatures.has(id))
+}
+
+/** Navigation items for enabled features */
+export interface NavItem {
+  id: FeatureId
+  label: string
+  path: string
+  icon: string
+}
+
+export function getNavItems(): NavItem[] {
+  const items: NavItem[] = [
+    { id: 'dashboard', label: 'Dashboard', path: '/', icon: '📊' },
+    { id: 'board', label: 'Board', path: '/board', icon: '📋' },
+    { id: 'standup', label: 'Standup', path: '/standup', icon: '☀️' },
+    { id: 'retro', label: 'Retro', path: '/retro', icon: '🔄' },
+    { id: 'inbox', label: 'Inbox', path: '/inbox', icon: '📬' },
+    { id: 'specs', label: 'Specs', path: '/specs', icon: '📐' },
+    { id: 'docs', label: 'Docs', path: '/docs', icon: '📄' },
+    { id: 'meetings', label: 'Meetings', path: '/meetings', icon: '🗓️' },
+    { id: 'rewards', label: 'Rewards', path: '/rewards', icon: '🏆' },
+    { id: 'admin', label: 'Admin', path: '/admin', icon: '⚙️' },
+  ]
+  return items.filter(item => isFeatureEnabled(item.id))
+}