create-arete-workspace 0.2.0

package/packages/gatsaeng-os/src/lib/vault/index.ts

@@ -0,0 +1,180 @@
+import fs from 'fs/promises'
+import path from 'path'
+import { nanoid } from 'nanoid'
+import { FOLDERS, PROFILE_PATH, type FolderKey } from './config'
+import { parseMarkdown, safeParseMarkdown, stringifyMarkdown } from './frontmatter'
+import type { ZodSchema } from 'zod'
+
+async function ensureDir(dirPath: string): Promise<void> {
+  await fs.mkdir(dirPath, { recursive: true })
+}
+
+async function atomicWrite(filePath: string, content: string): Promise<void> {
+  const tmpPath = `${filePath}.tmp`
+  await fs.writeFile(tmpPath, content, 'utf-8')
+  await fs.rename(tmpPath, filePath)
+}
+
+export async function listEntities<T>(
+  folder: FolderKey,
+  schema?: ZodSchema<T>
+): Promise<Array<{ data: T; content: string; filename: string }>> {
+  const dirPath = FOLDERS[folder]
+  await ensureDir(dirPath)
+
+  const files = await fs.readdir(dirPath)
+  const mdFiles = files.filter(f => f.endsWith('.md'))
+
+  const all = await Promise.all(
+    mdFiles.map(async (filename) => {
+      const raw = await fs.readFile(path.join(dirPath, filename), 'utf-8')
+      if (schema) {
+        const parsed = safeParseMarkdown<T>(raw, schema)
+        if (!parsed) return null // skip files that don't match schema
+        return { ...parsed, filename }
+      }
+      const parsed = parseMarkdown<T>(raw)
+      return { ...parsed, filename }
+    })
+  )
+
+  return all.filter((r): r is NonNullable<typeof r> => r !== null)
+}
+
+function matchesId(filename: string, id: string): boolean {
+  // Match patterns: prefix-{id}.md or just {id}.md
+  const name = filename.replace('.md', '')
+  return name === id || name.endsWith(`-${id}`)
+}
+
+export async function getEntity<T>(
+  folder: FolderKey,
+  id: string,
+  schema?: ZodSchema<T>
+): Promise<{ data: T; content: string } | null> {
+  const dirPath = FOLDERS[folder]
+  const files = await fs.readdir(dirPath)
+  const target = files.find(f => f.endsWith('.md') && matchesId(f, id))
+
+  if (!target) return null
+
+  const raw = await fs.readFile(path.join(dirPath, target), 'utf-8')
+  return parseMarkdown<T>(raw, schema)
+}
+
+export async function getEntityByDate<T>(
+  folder: FolderKey,
+  date: string,
+  schema?: ZodSchema<T>
+): Promise<{ data: T; content: string } | null> {
+  const dirPath = FOLDERS[folder]
+  const filePath = path.join(dirPath, `${date}.md`)
+
+  try {
+    const raw = await fs.readFile(filePath, 'utf-8')
+    return parseMarkdown<T>(raw, schema)
+  } catch {
+    return null
+  }
+}
+
+export async function createEntity<T extends object>(
+  folder: FolderKey,
+  data: Omit<T, 'id'> & { id?: string },
+  body?: string
+): Promise<T> {
+  const dirPath = FOLDERS[folder]
+  await ensureDir(dirPath)
+
+  const id = data.id || nanoid(10)
+  const entityData = { ...data, id } as T
+  const prefix = folder.replace(/s$/, '').replace(/Logs$/, '').replace(/Sessions$/, 'session')
+  const filename = `${prefix}-${id}.md`
+  const filePath = path.join(dirPath, filename)
+
+  const content = stringifyMarkdown(entityData as object, body)
+  await atomicWrite(filePath, content)
+
+  return entityData
+}
+
+export async function createDateEntity<T extends object>(
+  folder: FolderKey,
+  date: string,
+  data: T
+): Promise<T> {
+  const dirPath = FOLDERS[folder]
+  await ensureDir(dirPath)
+
+  const filePath = path.join(dirPath, `${date}.md`)
+  const content = stringifyMarkdown(data as object)
+  await atomicWrite(filePath, content)
+
+  return data
+}
+
+export async function updateEntity<T extends object>(
+  folder: FolderKey,
+  id: string,
+  updates: Partial<T>,
+  body?: string
+): Promise<T | null> {
+  const dirPath = FOLDERS[folder]
+  const files = await fs.readdir(dirPath)
+  const target = files.find(f => f.endsWith('.md') && matchesId(f, id))
+
+  if (!target) return null
+
+  const filePath = path.join(dirPath, target)
+  const raw = await fs.readFile(filePath, 'utf-8')
+  const parsed = parseMarkdown<T>(raw)
+
+  const updated = { ...parsed.data, ...updates } as T
+  const newBody = body !== undefined ? body : parsed.content
+  const content = stringifyMarkdown(updated as object, newBody)
+  await atomicWrite(filePath, content)
+
+  return updated
+}
+
+export async function updateDateEntity<T extends object>(
+  folder: FolderKey,
+  date: string,
+  data: T
+): Promise<T> {
+  const dirPath = FOLDERS[folder]
+  await ensureDir(dirPath)
+
+  const filePath = path.join(dirPath, `${date}.md`)
+  const content = stringifyMarkdown(data as object)
+  await atomicWrite(filePath, content)
+
+  return data
+}
+
+export async function deleteEntity(folder: FolderKey, id: string): Promise<boolean> {
+  const dirPath = FOLDERS[folder]
+  const files = await fs.readdir(dirPath)
+  const target = files.find(f => f.endsWith('.md') && matchesId(f, id))
+
+  if (!target) return false
+
+  await fs.unlink(path.join(dirPath, target))
+  return true
+}
+
+export async function getProfile<T>(schema?: ZodSchema<T>): Promise<{ data: T; content: string }> {
+  const raw = await fs.readFile(PROFILE_PATH, 'utf-8')
+  return parseMarkdown<T>(raw, schema)
+}
+
+export async function updateProfile<T extends object>(
+  updates: Partial<T>
+): Promise<T> {
+  const raw = await fs.readFile(PROFILE_PATH, 'utf-8')
+  const parsed = parseMarkdown<T>(raw)
+  const updated = { ...parsed.data, ...updates } as T
+  const content = stringifyMarkdown(updated as object, parsed.content)
+  await fs.writeFile(PROFILE_PATH, content, 'utf-8')
+  return updated
+}

package/packages/gatsaeng-os/src/lib/vault/schemas.ts

@@ -0,0 +1,274 @@
+import { z } from 'zod'
+
+// ─── Area ───
+export const areaSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  icon: z.string().default('📌'),
+  status: z.enum(['active', 'completed', 'archived']).default('active'),
+  linked_goals: z.array(z.string()).default([]),
+  created: z.string(),
+})
+
+// ─── Key Metric ───
+const keyMetricSchema = z.object({
+  name: z.string(),
+  current: z.number(),
+  target: z.number(),
+  unit: z.string(),
+})
+
+// ─── Goal ───
+export const goalSchema = z.object({
+  id: z.string(),
+  area_id: z.string().optional(),
+  title: z.string(),
+  description: z.string().optional(),
+  type: z.string().default('general'),
+  status: z.enum(['active', 'completed', 'archived']).default('active'),
+  color: z.string().default('#f5a623'),
+  created: z.string().optional(), // v2 files may only have created_at
+  ai_next_review: z.string().optional(),
+  ai_diagnosis: z.string().optional(),
+  ai_direction: z.string().optional(),
+  linked_milestones: z.array(z.string()).default([]),
+  linked_routines: z.array(z.string()).default([]),
+  linked_projects: z.array(z.string()).default([]),
+  key_metrics: z.array(keyMetricSchema).default([]),
+  why_statement: z.string().optional(),
+  identity_statement: z.string().optional(),
+  when_where_how: z.string().optional(),
+  // v2 compat
+  target_value: z.number().optional(),
+  current_value: z.number().optional(),
+  unit: z.string().optional(),
+  due_date: z.string().optional(),
+  core_value: z.string().optional(),
+  created_at: z.string().optional(),
+  updated_at: z.string().optional(),
+})
+
+// ─── Milestone ───
+export const milestoneSchema = z.object({
+  id: z.string(),
+  goal_id: z.string(),
+  title: z.string(),
+  target_value: z.number(),
+  current_value: z.number().default(0),
+  unit: z.string(),
+  due_date: z.string(),
+  status: z.enum(['active', 'completed', 'archived']).default('active'),
+  created_by: z.enum(['user', 'ai']).default('user'),
+  created: z.string(),
+})
+
+// ─── Project ───
+export const projectSchema = z.object({
+  id: z.string(),
+  goal_id: z.string().optional(),
+  milestone_id: z.string().optional(),
+  title: z.string(),
+  description: z.string().optional(),
+  status: z.enum(['active', 'completed', 'archived']).default('active'),
+  color: z.string().default('#7c5cbf'),
+  due_date: z.string().optional(),
+  default_view: z.enum(['kanban', 'table', 'calendar', 'list']).default('kanban'),
+  created_by: z.enum(['user', 'ai']).optional(),
+  created_at: z.string(),
+  updated_at: z.string(),
+})
+
+// ─── Task (project-level) ───
+export const taskSchema = z.object({
+  id: z.string(),
+  project_id: z.string(),
+  parent_task_id: z.string().optional(),
+  title: z.string(),
+  description: z.string().optional(),
+  status: z.enum(['backlog', 'todo', 'doing', 'done']).default('backlog'),
+  priority: z.enum(['low', 'medium', 'high', 'urgent']).default('medium'),
+  energy_required: z.enum(['low', 'medium', 'high']).optional(),
+  tag: z.string().optional(),
+  due_date: z.string().optional(),
+  position: z.number().default(0),
+  goal_ids: z.array(z.string()).optional(),
+  area_id: z.string().optional(),
+  created_at: z.string(),
+  updated_at: z.string(),
+})
+
+// ─── Book ───
+export const bookSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  author: z.string(),
+  status: z.enum(['reading', 'completed', 'want_to_read', 'dropped']).default('want_to_read'),
+  rating: z.number().min(1).max(5).optional(),
+  total_pages: z.number().optional(),
+  current_page: z.number().optional(),
+  goal_id: z.string().optional(),
+  started_at: z.string().optional(),
+  finished_at: z.string().optional(),
+  created_at: z.string().optional(),
+})
+
+// ─── Calendar Event ───
+export const calendarEventSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  date: z.string(),
+  time_start: z.string().optional(),
+  time_end: z.string().optional(),
+  all_day: z.boolean().optional(),
+  category: z.enum(['work', 'personal', 'health', 'study', 'social', 'other']).optional(),
+  location: z.string().optional(),
+  description: z.string().optional(),
+  goal_id: z.string().optional(),
+  created_by: z.enum(['user', 'ai', 'telegram']).optional(),
+  created_at: z.string().optional(),
+})
+
+// ─── Note ───
+export const noteSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  type: z.enum(['note', 'file', 'reference', 'link']).default('note'),
+  priority: z.union([z.literal(1), z.literal(2), z.literal(3)]).default(2),
+  area_id: z.string().optional(),
+  project_id: z.string().optional(),
+  url: z.string().optional(),
+  created_at: z.string(),
+  updated_at: z.string(),
+})
+
+// ─── Daily Manifest ───
+export const dailyManifestSchema = z.object({
+  date: z.string(),
+  gatsaeng_score: z.number().default(0),
+  routines_done: z.number().default(0),
+  routines_total: z.number().default(0),
+  focus_minutes: z.number().default(0),
+  timing_note: z.string().optional(),
+  growth_actions: z.object({
+    core: z.array(z.string()).default([]),
+    filler: z.array(z.string()).default([]),
+    missed: z.array(z.string()).default([]),
+  }).optional(),
+})
+
+// ─── Routine ───
+export const routineSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  area_id: z.string().optional(),
+  goal_id: z.string().optional(),
+  scheduled_time: z.string().optional(),
+  scheduled_days: z.array(z.number()).default([1, 2, 3, 4, 5, 6, 7]),
+  trigger_cue: z.string().optional(),
+  trigger_type: z.enum(['time', 'event', 'location']).default('time'),
+  after_routine_id: z.string().nullable().optional(),
+  reward_note: z.string().optional(),
+  energy_required: z.enum(['low', 'medium', 'high']).default('medium'),
+  streak: z.number().default(0),
+  longest_streak: z.number().default(0),
+  is_active: z.boolean().default(true),
+  position: z.number().default(0),
+  created_by: z.enum(['user', 'ai']).optional(),
+  created: z.string().optional(), // v2 files may only have created_at
+  // v2 compat
+  days_of_week: z.array(z.number()).optional(),
+  created_at: z.string().optional(),
+})
+
+// ─── Routine Log ───
+export const routineLogSchema = z.object({
+  date: z.string(),
+  completions: z.array(z.object({
+    routine_id: z.string(),
+    completed_at: z.string(),
+    mood: z.number().min(1).max(5).optional(),
+  })),
+})
+
+// ─── Energy Log ───
+export const energyLogSchema = z.object({
+  date: z.string(),
+  entries: z.array(z.object({
+    hour: z.number().min(0).max(23),
+    level: z.number().min(1).max(5),
+    note: z.string().optional(),
+  })),
+})
+
+// ─── Focus Session ───
+export const focusSessionSchema = z.object({
+  id: z.string(),
+  date: z.string().optional(),
+  task_id: z.string().optional(),
+  duration_minutes: z.number(),
+  session_type: z.enum(['pomodoro_25', 'focus_90', 'deep_work']).default('pomodoro_25'),
+  energy_level: z.number().min(1).max(5).optional(),
+  completed: z.boolean().default(false),
+  started_at: z.string(),
+})
+
+// ─── Review ───
+export const reviewSchema = z.object({
+  id: z.string().optional(),
+  type: z.enum(['daily', 'weekly']).default('weekly'),
+  date: z.string().optional(),
+  week: z.string().optional(),
+  week_start: z.string().optional(),
+  week_end: z.string().optional(),
+  routines_completion_rate: z.number().optional(),
+  tasks_completed: z.number().optional(),
+  gatsaeng_score_total: z.number().optional(),
+  ai_reanalysis_triggered: z.boolean().optional(),
+  goal_ids_to_review: z.array(z.string()).optional(),
+  accomplished: z.string().optional(),
+  struggled: z.string().optional(),
+  learnings: z.string().optional(),
+  next_week_focus: z.string().optional(),
+  energy_pattern: z.string().optional(),
+  habit_insight: z.string().optional(),
+  mood: z.number().min(1).max(5).optional(),
+  score: z.number().optional(),
+  created_at: z.string().optional(),
+})
+
+// ─── Profile ───
+export const profileSchema = z.object({
+  display_name: z.string(),
+  level: z.number().default(1),
+  total_score: z.number().default(0),
+  longest_streak: z.number().default(0),
+  current_streak: z.number().default(0),
+  peak_hours: z.array(z.number()),
+  dashboard_widgets: z.array(z.enum(['routine', 'goals', 'heatmap', 'kanban', 'timer', 'zeigarnik', 'energy', 'dday', 'proactive'])),
+  created_at: z.string(),
+  updated_at: z.string(),
+})
+
+// ─── Timing Context (사주) ───
+export const timingContextSchema = z.object({
+  year: z.number(),
+  month_name: z.string(),
+  month_hanja: z.string(),
+  period_start: z.string(),
+  period_end: z.string(),
+  rating: z.number().min(1).max(5),
+  theme: z.string(),
+  key_insight: z.string(),
+  action_guide: z.string(),
+})
+
+// ─── Growth Scorecard (사주 L1~L4) ───
+export const growthScorecardSchema = z.object({
+  date: z.string(),
+  l4_timing: z.enum(['aligned', 'misaligned', 'counter']),
+  l3_chain: z.enum(['active', 'weak', 'depleted']),
+  l2_expansion: z.enum(['forward', 'stagnant', 'retreat']),
+  l1_correction: z.enum(['corrected', 'in_progress', 'stuck']),
+  health_defense: z.enum(['maintained', 'warning', 'collapsed']),
+  note: z.string().optional(),
+})

package/packages/gatsaeng-os/src/middleware.ts

@@ -0,0 +1,34 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { jwtVerify } from 'jose'
+
+export const config = {
+  matcher: ['/((?!_next/static|_next/image|favicon.ico|login).*)'],
+}
+
+const SECRET = new TextEncoder().encode(
+  process.env.SESSION_SECRET || 'build-placeholder'
+)
+
+export async function middleware(req: NextRequest) {
+  const { pathname } = req.nextUrl
+
+  // Public routes
+  if (pathname.startsWith('/login') || pathname === '/api/auth/login') {
+    return NextResponse.next()
+  }
+
+  const token = req.cookies.get('gs_auth')?.value
+
+  if (!token) {
+    return NextResponse.redirect(new URL('/login', req.url))
+  }
+
+  try {
+    await jwtVerify(token, SECRET)
+    return NextResponse.next()
+  } catch {
+    const res = NextResponse.redirect(new URL('/login', req.url))
+    res.cookies.delete('gs_auth')
+    return res
+  }
+}

package/packages/gatsaeng-os/src/stores/dashboardStore.ts

@@ -0,0 +1,26 @@
+'use client'
+
+import { create } from 'zustand'
+import { persist } from 'zustand/middleware'
+import type { WidgetId } from '@/types'
+
+interface DashboardStore {
+  activeWidgets: WidgetId[]
+  toggleWidget: (id: WidgetId) => void
+  reorderWidgets: (newOrder: WidgetId[]) => void
+}
+
+export const useDashboardStore = create<DashboardStore>()(
+  persist(
+    (set) => ({
+      activeWidgets: ['proactive', 'routine', 'goals', 'dday', 'zeigarnik', 'timer', 'energy'],
+      toggleWidget: (id) => set((s) => ({
+        activeWidgets: s.activeWidgets.includes(id)
+          ? s.activeWidgets.filter(w => w !== id)
+          : [...s.activeWidgets, id],
+      })),
+      reorderWidgets: (newOrder) => set({ activeWidgets: newOrder }),
+    }),
+    { name: 'gatsaeng-dashboard-layout' }
+  )
+)

package/packages/gatsaeng-os/src/stores/favoritesStore.ts

@@ -0,0 +1,47 @@
+'use client'
+
+import { create } from 'zustand'
+import { persist } from 'zustand/middleware'
+
+export type FavoriteType = 'note' | 'task' | 'goal' | 'project' | 'book'
+
+export interface FavoriteItem {
+  type: FavoriteType
+  id: string
+  title: string
+}
+
+interface FavoritesStore {
+  favorites: FavoriteItem[]
+  add: (item: FavoriteItem) => void
+  remove: (type: FavoriteType, id: string) => void
+  toggle: (item: FavoriteItem) => void
+  isFavorite: (type: FavoriteType, id: string) => boolean
+}
+
+export const useFavoritesStore = create<FavoritesStore>()(
+  persist(
+    (set, get) => ({
+      favorites: [],
+      add: (item) =>
+        set((s) => {
+          if (s.favorites.some((f) => f.type === item.type && f.id === item.id)) return s
+          return { favorites: [...s.favorites, item] }
+        }),
+      remove: (type, id) =>
+        set((s) => ({
+          favorites: s.favorites.filter((f) => !(f.type === type && f.id === id)),
+        })),
+      toggle: (item) => {
+        const exists = get().isFavorite(item.type, item.id)
+        if (exists) {
+          get().remove(item.type, item.id)
+        } else {
+          get().add(item)
+        }
+      },
+      isFavorite: (type, id) => get().favorites.some((f) => f.type === type && f.id === id),
+    }),
+    { name: 'gatsaeng-favorites' }
+  )
+)

package/packages/gatsaeng-os/src/stores/timerStore.ts

@@ -0,0 +1,65 @@
+'use client'
+
+import { create } from 'zustand'
+import type { SessionType } from '@/types'
+
+const DURATIONS: Record<SessionType, number> = {
+  pomodoro_25: 25 * 60,
+  focus_90: 90 * 60,
+  deep_work: 50 * 60,
+}
+
+interface TimerState {
+  seconds: number
+  isRunning: boolean
+  sessionType: SessionType
+  completedSessions: number
+  energyLevelAtStart: number | null
+  customMinutes: number
+  startedAt: string | null
+  start: () => void
+  pause: () => void
+  reset: () => void
+  tick: () => void
+  setSessionType: (type: SessionType) => void
+  setCustomMinutes: (minutes: number) => void
+  setEnergyLevel: (level: number) => void
+}
+
+export const useTimerStore = create<TimerState>((set, get) => ({
+  seconds: DURATIONS.pomodoro_25,
+  isRunning: false,
+  sessionType: 'pomodoro_25',
+  completedSessions: 0,
+  energyLevelAtStart: null,
+  customMinutes: 50,
+  startedAt: null,
+  start: () => {
+    const { startedAt } = get()
+    set({ isRunning: true, startedAt: startedAt ?? new Date().toISOString() })
+  },
+  pause: () => set({ isRunning: false }),
+  reset: () => {
+    const { sessionType, customMinutes } = get()
+    const secs = sessionType === 'deep_work' ? customMinutes * 60 : DURATIONS[sessionType]
+    set({ seconds: secs, isRunning: false, startedAt: null })
+  },
+  tick: () => {
+    const { seconds, completedSessions } = get()
+    if (seconds <= 1) {
+      set({ isRunning: false, seconds: 0, completedSessions: completedSessions + 1 })
+    } else {
+      set({ seconds: seconds - 1 })
+    }
+  },
+  setSessionType: (type) => {
+    const { customMinutes } = get()
+    const secs = type === 'deep_work' ? customMinutes * 60 : DURATIONS[type]
+    set({ sessionType: type, seconds: secs, isRunning: false })
+  },
+  setCustomMinutes: (minutes) => {
+    const clamped = Math.max(1, Math.min(180, minutes))
+    set({ customMinutes: clamped, seconds: clamped * 60, isRunning: false })
+  },
+  setEnergyLevel: (level) => set({ energyLevelAtStart: level }),
+}))