popilot 0.3.0 → 0.5.0

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

@@ -0,0 +1,134 @@
+/**
+ * PM Store — Type definitions, DB row mappers, and constants
+ */
+
+// ── Domain types ──
+
+export type StoryStatus = 'draft' | 'backlog' | 'ready' | 'in-progress' | 'review' | 'done'
+export type TaskStatus = 'todo' | 'in-progress' | 'done'
+export type Priority = 'low' | 'medium' | 'high' | 'critical'
+export type EpicStatus = 'active' | 'completed' | 'archived'
+
+export interface PmEpic {
+  id: number
+  title: string
+  description: string | null
+  status: EpicStatus
+  owner: string | null
+  createdAt: string
+  updatedAt: string
+}
+
+export interface PmStory {
+  id: number
+  epicId: number | null
+  sprint: string
+  title: string
+  description: string | null
+  acceptanceCriteria: string | null
+  assignee: string | null
+  status: StoryStatus
+  priority: Priority
+  area: string
+  storyPoints: number | null
+  sortOrder: number
+  createdAt: string
+  updatedAt: string
+}
+
+export interface PmTask {
+  id: number
+  storyId: number
+  title: string
+  assignee: string | null
+  status: TaskStatus
+  description: string | null
+  sortOrder: number
+  createdAt: string
+  updatedAt: string
+}
+
+// ── Row mappers ──
+
+import type { PmEpicRow, PmStoryRow, PmTaskRow } from '@/api/types'
+
+export function mapEpic(r: PmEpicRow): PmEpic {
+  return {
+    id: r.id,
+    title: r.title,
+    description: r.description,
+    status: (r.status ?? 'active') as EpicStatus,
+    owner: r.owner,
+    createdAt: r.created_at,
+    updatedAt: r.updated_at,
+  }
+}
+
+export function mapStory(r: PmStoryRow): PmStory {
+  return {
+    id: r.id,
+    epicId: r.epic_id,
+    sprint: r.sprint ?? '',
+    title: r.title,
+    description: r.description,
+    acceptanceCriteria: r.acceptance_criteria,
+    assignee: r.assignee,
+    status: r.status as StoryStatus,
+    priority: (r.priority ?? 'medium') as Priority,
+    area: r.area ?? 'FE',
+    storyPoints: r.story_points,
+    sortOrder: r.sort_order,
+    createdAt: r.created_at,
+    updatedAt: r.updated_at,
+  }
+}
+
+export function mapTask(r: PmTaskRow): PmTask {
+  return {
+    id: r.id,
+    storyId: r.story_id,
+    title: r.title,
+    assignee: r.assignee,
+    status: r.status as TaskStatus,
+    description: r.description,
+    sortOrder: r.sort_order,
+    createdAt: r.created_at,
+    updatedAt: r.updated_at,
+  }
+}
+
+// ── Status constants ──
+
+export const STORY_STATUSES: StoryStatus[] = ['draft', 'backlog', 'ready', 'in-progress', 'review', '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
+export const EPIC_STATUSES: EpicStatus[] = ['active', 'completed', 'archived']
+
+export const STORY_STATUS_LABELS: Record<StoryStatus, string> = {
+  'draft': 'Draft',
+  'backlog': 'Backlog',
+  'ready': 'Ready',
+  'in-progress': 'In Progress',
+  'review': 'Review',
+  'done': 'Done',
+}
+
+export const TASK_STATUS_LABELS: Record<TaskStatus, string> = {
+  'todo': 'To Do',
+  'in-progress': 'In Progress',
+  'done': 'Done',
+}
+
+export const PRIORITY_LABELS: Record<Priority, string> = {
+  'low': 'Low',
+  'medium': 'Medium',
+  'high': 'High',
+  'critical': 'Critical',
+}
+
+export const EPIC_STATUS_LABELS: Record<EpicStatus, string> = {
+  'active': 'Active',
+  'completed': 'Completed',
+  'archived': 'Archived',
+}

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

@@ -0,0 +1,139 @@
+/**
+ * Auth composable — Token-based authentication for spec-site.
+ *
+ * Supports:
+ * - URL token parameter (?token=...) with auto-cleanup
+ * - localStorage persistence
+ * - API verification with offline fallback
+ *
+ * In static mode, auth is disabled (always authenticated).
+ */
+
+import { ref, readonly } from 'vue'
+import { isStaticMode } from '@/api/client'
+import { useUser } from './useUser'
+
+const AUTH_STORAGE_KEY = 'spec-auth-token'
+const AUTH_USER_KEY = 'spec-auth-user'
+
+const isAuthenticated = ref(false)
+const authUser = ref<string | null>(null)
+const authLoading = ref(false)
+const _token = ref<string | null>(null)
+
+// Static mode: always authenticated
+if (isStaticMode()) {
+  isAuthenticated.value = true
+  authUser.value = 'local'
+} else {
+  // Restore from localStorage
+  const savedToken = localStorage.getItem(AUTH_STORAGE_KEY)
+  const savedUser = localStorage.getItem(AUTH_USER_KEY)
+  if (savedToken && savedUser) {
+    _token.value = savedToken
+    authUser.value = savedUser
+    isAuthenticated.value = true
+    const { setUser } = useUser()
+    setUser(savedUser)
+  }
+}
+
+async function verifyToken(token: string): Promise<string | null> {
+  if (isStaticMode()) return 'local'
+
+  const apiUrl = import.meta.env.VITE_API_URL as string
+  const savedToken = localStorage.getItem(AUTH_STORAGE_KEY)
+  const savedUser = localStorage.getItem(AUTH_USER_KEY)
+
+  try {
+    const resp = await fetch(`${apiUrl}/api/auth/verify`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ token }),
+      signal: AbortSignal.timeout(5000),
+    })
+    if (resp.ok) {
+      const data = await resp.json()
+      if (data.userName) return String(data.userName)
+    }
+  } catch {
+    // API unreachable — use cached auth
+    if (savedToken === token && savedUser) {
+      return savedUser
+    }
+  }
+  return null
+}
+
+async function login(token: string): Promise<boolean> {
+  authLoading.value = true
+  try {
+    const userName = await verifyToken(token)
+    if (!userName) return false
+
+    _token.value = token
+    authUser.value = userName
+    isAuthenticated.value = true
+
+    localStorage.setItem(AUTH_STORAGE_KEY, token)
+    localStorage.setItem(AUTH_USER_KEY, userName)
+
+    const { setUser } = useUser()
+    setUser(userName)
+
+    // Log activity (non-critical)
+    try {
+      const { apiPost } = await import('@/api/client')
+      await apiPost('/api/v2/user/activity', { userName })
+    } catch { /* non-critical */ }
+
+    return true
+  } finally {
+    authLoading.value = false
+  }
+}
+
+function logout() {
+  _token.value = null
+  authUser.value = null
+  isAuthenticated.value = false
+  localStorage.removeItem(AUTH_STORAGE_KEY)
+  localStorage.removeItem(AUTH_USER_KEY)
+
+  const { clearUser } = useUser()
+  clearUser()
+}
+
+async function tryAutoLogin(): Promise<boolean> {
+  if (isStaticMode()) return true
+
+  // 1) URL token parameter
+  const params = new URLSearchParams(window.location.search)
+  const urlToken = params.get('token')
+  if (urlToken) {
+    // Remove token from URL (security: prevent referrer/history exposure)
+    const cleanUrl = new URL(window.location.href)
+    cleanUrl.searchParams.delete('token')
+    window.history.replaceState({}, '', cleanUrl.pathname + cleanUrl.search + cleanUrl.hash)
+    return await login(urlToken)
+  }
+
+  // 2) localStorage token
+  const stored = localStorage.getItem(AUTH_STORAGE_KEY)
+  if (stored) {
+    return await login(stored)
+  }
+
+  return false
+}
+
+export function useAuth() {
+  return {
+    isAuthenticated: readonly(isAuthenticated),
+    authUser: readonly(authUser),
+    authLoading: readonly(authLoading),
+    login,
+    logout,
+    tryAutoLogin,
+  }
+}

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

@@ -1,4 +1,12 @@
+/**
+ * Memo composable — Page-level notes/memos
+ *
+ * Always uses localStorage as primary storage.
+ * In API mode, also syncs with backend.
+ */
+
 import { ref, computed } from 'vue'
+import { isStaticMode } from '@/api/client'
 
 export interface MemoItem {
   id: number
@@ -36,34 +44,34 @@ export function useMemo(pageId: string) {
     localStorage.setItem(STORAGE_KEY, JSON.stringify(memos.value))
   }
 
-  // Turso dynamic load attempt (falls back to localStorage)
-  async function tryLoadFromTurso() {
+  async function tryLoadFromApi() {
+    if (isStaticMode()) return
+
     try {
-      const { query } = await import('./useTurso')
-      const r = await query<{ id: number; content: string; author: string; created_at: string }>(
-        'SELECT id, content, author, created_at FROM memos WHERE page_id = ? ORDER BY created_at DESC',
-        [pageId],
+      const { apiGet } = await import('@/api/client')
+      const r = await apiGet<{ memos: Array<{ id: number; content: string; author: string; created_at: string }> }>(
+        '/api/v2/memos',
+        { pageId },
       )
-      if (!r.error) {
-        memos.value = r.rows.map((row) => ({
+      if (!r.error && r.data) {
+        memos.value = r.data.memos.map((row) => ({
           id: Number(row.id),
           text: String(row.content),
           author: String(row.author),
           ts: new Date(row.created_at + 'Z').getTime(),
         }))
-      } else {
+      } else if (r.error) {
         error.value = r.error
       }
     } catch (err) {
-      error.value = err instanceof Error ? err.message : 'Turso load failed'
-      // Keep localStorage fallback silently in UI behavior
+      error.value = err instanceof Error ? err.message : 'API load failed'
     }
   }
 
   async function loadMemos() {
     loading.value = true
     error.value = null
-    await tryLoadFromTurso()
+    await tryLoadFromApi()
     loading.value = false
   }
 
@@ -71,19 +79,18 @@ export function useMemo(pageId: string) {
     const trimmed = text.trim()
     if (!trimmed) return false
 
-    // Try Turso
-    try {
-      const { execute } = await import('./useTurso')
-      const r = await execute('INSERT INTO memos (page_id, content, author) VALUES (?, ?, ?)', [
-        pageId, trimmed, author,
-      ])
-      if (!r.error) {
-        await tryLoadFromTurso()
-        return true
+    if (!isStaticMode()) {
+      try {
+        const { apiPost } = await import('@/api/client')
+        const r = await apiPost('/api/v2/memos', { pageId, content: trimmed, author })
+        if (!r.error) {
+          await tryLoadFromApi()
+          return true
+        }
+        error.value = r.error ?? 'API save failed'
+      } catch (err) {
+        error.value = err instanceof Error ? err.message : 'API save failed'
       }
-      error.value = r.error ?? 'Turso save failed'
-    } catch (err) {
-      error.value = err instanceof Error ? err.message : 'Turso save failed'
     }
 
     // localStorage fallback
@@ -93,16 +100,18 @@ export function useMemo(pageId: string) {
   }
 
   async function deleteMemo(id: number) {
-    try {
-      const { execute } = await import('./useTurso')
-      const r = await execute('DELETE FROM memos WHERE id = ?', [id])
-      if (!r.error) {
-        await tryLoadFromTurso()
-        return
+    if (!isStaticMode()) {
+      try {
+        const { apiDelete } = await import('@/api/client')
+        const r = await apiDelete(`/api/v2/memos/${id}`)
+        if (!r.error) {
+          await tryLoadFromApi()
+          return
+        }
+        error.value = r.error ?? 'API delete failed'
+      } catch (err) {
+        error.value = err instanceof Error ? err.message : 'API delete failed'
       }
-      error.value = r.error ?? 'Turso delete failed'
-    } catch (err) {
-      error.value = err instanceof Error ? err.message : 'Turso delete failed'
     }
 
     memos.value = memos.value.filter((m) => m.id !== id)
@@ -110,12 +119,14 @@ export function useMemo(pageId: string) {
   }
 
   async function clearAll() {
-    try {
-      const { execute } = await import('./useTurso')
-      const r = await execute('DELETE FROM memos WHERE page_id = ?', [pageId])
-      if (r.error) error.value = r.error
-    } catch (err) {
-      error.value = err instanceof Error ? err.message : 'Turso clear failed'
+    if (!isStaticMode()) {
+      try {
+        const { apiDelete } = await import('@/api/client')
+        const r = await apiDelete('/api/v2/memos', { pageId })
+        if (r.error) error.value = r.error
+      } catch (err) {
+        error.value = err instanceof Error ? err.message : 'API clear failed'
+      }
     }
     memos.value = []
     saveToLocal()
@@ -130,7 +141,7 @@ export function useMemo(pageId: string) {
     return `${mm}/${dd} ${hh}:${mi}`
   }
 
-  // Immediately load from localStorage (sync), then try Turso (async)
+  // Immediately load from localStorage (sync), then try API (async)
   loadFromLocal()
   loadMemos()
 

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

@@ -0,0 +1,202 @@
+/**
+ * Navigation store — API-backed sprints & epics
+ *
+ * Singleton pattern: refs are module-level, shared across all consumers.
+ * Initialized with fallback data so router/AppHeader work synchronously.
+ *
+ * In static mode, uses fallback data only (no API calls).
+ * In API mode, fetches from backend and overwrites refs.
+ */
+
+import { ref } from 'vue'
+import { apiGet, apiPost, apiPatch, apiDelete, isStaticMode } from '@/api/client'
+import type { NavApiResponse } from '@/api/types'
+import {
+  type SprintConfig, type PageConfig,
+  FALLBACK_SPRINTS, FALLBACK_EPICS,
+} from './navTypes'
+
+export type { SprintConfig, PageConfig } from './navTypes'
+
+// ── Singleton state ──
+
+export const sprints = ref<SprintConfig[]>([...FALLBACK_SPRINTS])
+export const epics = ref<PageConfig[]>([...FALLBACK_EPICS])
+export const loaded = ref(false)
+
+// ── Read helpers (synchronous, use current ref values) ──
+
+export function getActiveSprint(): SprintConfig {
+  return sprints.value.find(s => s.active) ?? sprints.value[0]
+}
+
+export function getPagesByCategory(sprint: string, category: string): PageConfig[] {
+  return epics.value.filter(p => p.sprint === sprint && p.category === category)
+}
+
+// ── API loading ──
+
+export async function loadNavData(): Promise<void> {
+  if (isStaticMode()) {
+    loaded.value = true
+    return
+  }
+
+  const { data, error } = await apiGet<NavApiResponse>('/api/v2/nav')
+  if (error || !data) return
+
+  if (data.sprints.length > 0) {
+    sprints.value = data.sprints.map(r => ({
+      id: r.id,
+      label: r.label,
+      theme: r.theme,
+      active: r.active === 1,
+      startDate: r.start_date,
+      endDate: r.end_date,
+      sortOrder: r.sort_order,
+    }))
+  }
+
+  if (data.epics.length > 0) {
+    epics.value = data.epics.map(r => ({
+      id: r.epic_id,
+      label: r.label,
+      badge: r.badge ?? undefined,
+      category: r.category,
+      sprint: r.sprint,
+      description: r.description ?? undefined,
+      sortOrder: r.sort_order,
+      uid: r.uid ?? `${r.sprint}:${r.epic_id}`,
+      originSprint: r.origin_sprint ?? r.sprint,
+    }))
+  }
+
+  loaded.value = true
+}
+
+// ── CRUD: Sprints ──
+
+export async function addSprint(data: {
+  id: string
+  label: string
+  theme: string
+  startDate?: string | null
+  endDate?: string | null
+}): Promise<{ error?: string }> {
+  if (isStaticMode()) return { error: 'CRUD not available in static mode' }
+  const maxOrder = sprints.value.reduce((max, s) => Math.max(max, s.sortOrder), -1)
+  const { error } = await apiPost('/api/v2/nav/sprints', {
+    id: data.id, label: data.label, theme: data.theme,
+    startDate: data.startDate ?? null, endDate: data.endDate ?? null,
+    sortOrder: maxOrder + 1,
+  })
+  if (error) return { error }
+  await loadNavData()
+  return {}
+}
+
+export async function updateSprint(id: string, data: {
+  label?: string
+  theme?: string
+  startDate?: string | null
+  endDate?: string | null
+}): Promise<{ error?: string }> {
+  if (isStaticMode()) return { error: 'CRUD not available in static mode' }
+  const { error } = await apiPatch(`/api/v2/nav/sprints/${id}`, data as Record<string, unknown>)
+  if (error) return { error }
+  await loadNavData()
+  return {}
+}
+
+export async function deleteSprint(id: string): Promise<{ error?: string }> {
+  if (isStaticMode()) return { error: 'CRUD not available in static mode' }
+  const { error } = await apiDelete(`/api/v2/nav/sprints/${id}`)
+  if (error) return { error }
+  await loadNavData()
+  return {}
+}
+
+export async function setActiveSprint(id: string): Promise<{ error?: string }> {
+  if (isStaticMode()) return { error: 'CRUD not available in static mode' }
+  const { error } = await apiPost(`/api/v2/nav/sprints/${id}/activate`, {})
+  if (error) return { error }
+  await loadNavData()
+  return {}
+}
+
+// ── CRUD: Epics ──
+
+export async function addEpic(sprint: string, data: {
+  epicId: string
+  label: string
+  badge?: string | null
+  category?: string
+  description?: string | null
+}): Promise<{ error?: string }> {
+  if (isStaticMode()) return { error: 'CRUD not available in static mode' }
+  const currentEpics = epics.value.filter(e => e.sprint === sprint)
+  const maxOrder = currentEpics.reduce((max, e) => Math.max(max, e.sortOrder), -1)
+  const uid = `${sprint}:${data.epicId}`
+  const { error } = await apiPost('/api/v2/nav/epics', {
+    sprint, epicId: data.epicId, label: data.label,
+    badge: data.badge ?? null, category: data.category ?? 'policy',
+    description: data.description ?? null, sortOrder: maxOrder + 1,
+    uid, originSprint: sprint,
+  })
+  if (error) return { error }
+  await loadNavData()
+  return {}
+}
+
+export async function updateEpic(sprint: string, epicId: string, data: {
+  label?: string
+  badge?: string | null
+  category?: string
+  description?: string | null
+}): Promise<{ error?: string }> {
+  if (isStaticMode()) return { error: 'CRUD not available in static mode' }
+  const { error } = await apiPatch(`/api/v2/nav/epics/${sprint}/${epicId}`, data as Record<string, unknown>)
+  if (error) return { error }
+  await loadNavData()
+  return {}
+}
+
+export async function deleteEpic(sprint: string, epicId: string): Promise<{ error?: string }> {
+  if (isStaticMode()) return { error: 'CRUD not available in static mode' }
+  const { error } = await apiDelete(`/api/v2/nav/epics/${sprint}/${epicId}`)
+  if (error) return { error }
+  await loadNavData()
+  return {}
+}
+
+export async function carryOverEpic(
+  uid: string,
+  targetSprint: string,
+  newEpicId: string,
+  newLabel?: string,
+  newBadge?: string,
+): Promise<{ error?: string }> {
+  if (isStaticMode()) return { error: 'CRUD not available in static mode' }
+  const epic = epics.value.find(e => e.uid === uid)
+  if (!epic) return { error: `Epic not found: ${uid}` }
+
+  const targetEpics = epics.value.filter(e => e.sprint === targetSprint)
+  const maxOrder = targetEpics.reduce((max, e) => Math.max(max, e.sortOrder), -1)
+
+  const { error } = await apiPost('/api/v2/nav/epics/carry-over', {
+    sprint: targetSprint,
+    epicId: newEpicId,
+    label: newLabel ?? epic.label,
+    badge: newBadge ?? epic.badge ?? null,
+    category: epic.category,
+    description: epic.description ?? null,
+    sortOrder: maxOrder + 1,
+    uid,
+    originSprint: epic.originSprint ?? epic.sprint,
+    oldSprint: epic.sprint,
+    oldEpicId: epic.id,
+  })
+  if (error) return { error }
+  await loadNavData()
+  return {}
+}