create-arete-workspace 0.2.0

package/packages/gatsaeng-os/src/hooks/useTiming.ts

@@ -0,0 +1,27 @@
+'use client'
+
+import { useQuery } from '@tanstack/react-query'
+
+export interface TimingContext {
+  month: string
+  heavenly_stem: string
+  earthly_branch: string
+  pillar: string
+  rating: number
+  theme: string
+  insight: string
+  action_guide: string[]
+  caution?: string[]
+}
+
+export function useCurrentTiming() {
+  return useQuery({
+    queryKey: ['timing', 'current'],
+    queryFn: async (): Promise<TimingContext | null> => {
+      const res = await fetch('/api/timing/current')
+      if (!res.ok) return null
+      return res.json()
+    },
+    staleTime: 1000 * 60 * 60, // 1h — timing doesn't change often
+  })
+}

package/packages/gatsaeng-os/src/lib/apiFetch.ts

@@ -0,0 +1,14 @@
+/**
+ * Shared API fetch with error handling.
+ * All hooks should use this instead of raw fetch + .json().
+ */
+export async function apiFetch<T = void>(url: string, init?: RequestInit): Promise<T> {
+  const res = await fetch(url, init)
+  if (!res.ok) {
+    let detail = ''
+    try { const body = await res.json(); detail = body.error || body.message || '' } catch {}
+    throw new Error(detail ? `HTTP ${res.status}: ${detail}` : `HTTP ${res.status}`)
+  }
+  const text = await res.text()
+  return (text ? JSON.parse(text) : undefined) as T
+}

package/packages/gatsaeng-os/src/lib/auth.ts

@@ -0,0 +1,32 @@
+import { SignJWT, jwtVerify } from 'jose'
+
+const SECRET = new TextEncoder().encode(
+  process.env.SESSION_SECRET || (() => { throw new Error('SESSION_SECRET not set') })()
+)
+
+export const COOKIE_NAME = 'gs_auth'
+export const COOKIE_MAX_AGE = 7 * 24 * 60 * 60 // 7 days
+
+export async function signToken(payload: { username: string }) {
+  return new SignJWT(payload)
+    .setProtectedHeader({ alg: 'HS256' })
+    .setIssuedAt()
+    .setExpirationTime('7d')
+    .sign(SECRET)
+}
+
+export async function verifyToken(token: string) {
+  try {
+    const { payload } = await jwtVerify(token, SECRET)
+    return payload as { username: string }
+  } catch {
+    return null
+  }
+}
+
+export function checkCredentials(username: string, password: string) {
+  return (
+    username === process.env.AUTH_USERNAME &&
+    password === process.env.AUTH_PASSWORD
+  )
+}

package/packages/gatsaeng-os/src/lib/date.ts

@@ -0,0 +1,7 @@
+/**
+ * Get today's date in YYYY-MM-DD format, always in Asia/Seoul timezone.
+ * Prevents UTC-based date shifts during 00:00-09:00 KST.
+ */
+export function getToday(): string {
+  return new Date().toLocaleDateString('en-CA', { timeZone: 'Asia/Seoul' })
+}

package/packages/gatsaeng-os/src/lib/editor/markdown.ts

@@ -0,0 +1,35 @@
+import TurndownService from 'turndown'
+import { marked } from 'marked'
+
+// ─── Markdown → HTML ───
+export function markdownToHtml(md: string): string {
+  if (!md || !md.trim()) return ''
+  return marked.parse(md, { async: false }) as string
+}
+
+// ─── HTML → Markdown ───
+const turndown = new TurndownService({
+  headingStyle: 'atx',
+  codeBlockStyle: 'fenced',
+  bulletListMarker: '-',
+})
+
+// Task list support
+turndown.addRule('taskListItem', {
+  filter: (node) => {
+    return (
+      node.nodeName === 'LI' &&
+      node.getAttribute('data-type') === 'taskItem'
+    )
+  },
+  replacement: (content, node) => {
+    const checked = (node as HTMLElement).getAttribute('data-checked') === 'true'
+    const cleaned = content.replace(/^\n+/, '').replace(/\n+$/, '')
+    return `- [${checked ? 'x' : ' '}] ${cleaned}\n`
+  },
+})
+
+export function htmlToMarkdown(html: string): string {
+  if (!html || !html.trim()) return ''
+  return turndown.turndown(html).trim()
+}

package/packages/gatsaeng-os/src/lib/llm-governor.ts

@@ -0,0 +1,167 @@
+/**
+ * LLM Call Governor — Layer 5 Runtime Governance
+ * Based on Matthew Berman's OpenClaw security design
+ *
+ * Protection layers:
+ * 1. Spend limit  — sliding 5-min window, hard cap $15
+ * 2. Volume limit — 200 calls/10min global, per-caller overrides
+ * 3. Lifetime counter — 500 calls/process max
+ * 4. Duplicate detection — hash cache, TTL 60s
+ */
+
+type CallerConfig = {
+  maxPer10Min?: number
+}
+
+const CALLERS: Record<string, CallerConfig> = {
+  'voice/chat': { maxPer10Min: 40 },
+  'voice/transcribe': { maxPer10Min: 60 },
+  'voice/tts': { maxPer10Min: 60 },
+  'default': { maxPer10Min: 200 },
+}
+
+// Estimated cost per 1K tokens (input+output blended)
+const COST_PER_CALL: Record<string, number> = {
+  'gpt-4o': 0.010,
+  'gpt-4o-mini': 0.0003,
+  'whisper': 0.006, // per minute, approximate
+  'tts': 0.015,     // per 1K chars
+  'default': 0.010,
+}
+
+// --- In-memory state (resets on process restart) ---
+const state = {
+  lifetimeCount: 0,
+  spendWindow: [] as { ts: number; cost: number }[],
+  volumeWindow: [] as { ts: number; caller: string }[],
+  callerCounts: new Map<string, { ts: number }[]>(),
+  hashCache: new Map<string, { result: unknown; ts: number }>(),
+}
+
+const LIFETIME_LIMIT = 500
+const SPEND_WINDOW_MS = 5 * 60 * 1000   // 5 min
+const SPEND_WARN = 5    // $5
+const SPEND_HARD = 15   // $15
+const VOLUME_WINDOW_MS = 10 * 60 * 1000 // 10 min
+const VOLUME_GLOBAL = 200
+const HASH_TTL_MS = 60 * 1000           // 60s
+
+function now() { return Date.now() }
+
+function pruneWindow<T extends { ts: number }>(arr: T[], windowMs: number): T[] {
+  const cutoff = now() - windowMs
+  return arr.filter(e => e.ts > cutoff)
+}
+
+function hashPrompt(prompt: string): string {
+  // Simple djb2 hash — good enough for dedup
+  let h = 5381
+  for (let i = 0; i < Math.min(prompt.length, 2000); i++) {
+    h = ((h << 5) + h) ^ prompt.charCodeAt(i)
+    h = h >>> 0
+  }
+  return h.toString(16)
+}
+
+export type GovernorResult =
+  | { ok: true; cached: false }
+  | { ok: true; cached: true; result: unknown }
+  | { ok: false; reason: string; code: 'SPEND_LIMIT' | 'VOLUME_LIMIT' | 'LIFETIME_LIMIT' }
+
+/**
+ * Check before making an LLM call.
+ * @param caller  e.g. 'voice/chat', 'voice/transcribe'
+ * @param prompt  The prompt text (for dedup hash)
+ * @param model   Model name key (for cost estimate)
+ */
+export function governorCheck(
+  caller: string,
+  prompt: string,
+  model = 'default'
+): GovernorResult {
+  // 1. Lifetime limit
+  if (state.lifetimeCount >= LIFETIME_LIMIT) {
+    return { ok: false, reason: `Lifetime LLM call limit reached (${LIFETIME_LIMIT})`, code: 'LIFETIME_LIMIT' }
+  }
+
+  // 2. Spend window
+  state.spendWindow = pruneWindow(state.spendWindow, SPEND_WINDOW_MS)
+  const totalSpend = state.spendWindow.reduce((s, e) => s + e.cost, 0)
+  if (totalSpend >= SPEND_HARD) {
+    return { ok: false, reason: `Spend hard cap hit ($${SPEND_HARD}/5min). Current: $${totalSpend.toFixed(3)}`, code: 'SPEND_LIMIT' }
+  }
+  if (totalSpend >= SPEND_WARN) {
+    console.warn(`[llm-governor] ⚠️ Spend warning: $${totalSpend.toFixed(3)} in last 5min (limit $${SPEND_HARD})`)
+  }
+
+  // 3. Global volume window
+  state.volumeWindow = pruneWindow(state.volumeWindow, VOLUME_WINDOW_MS)
+  if (state.volumeWindow.length >= VOLUME_GLOBAL) {
+    return { ok: false, reason: `Global volume limit hit (${VOLUME_GLOBAL}/10min)`, code: 'VOLUME_LIMIT' }
+  }
+
+  // 4. Per-caller volume
+  const callerCfg = CALLERS[caller] ?? CALLERS['default']
+  const callerMax = callerCfg.maxPer10Min ?? 200
+  const callerWindow = pruneWindow(state.callerCounts.get(caller) ?? [], VOLUME_WINDOW_MS)
+  if (callerWindow.length >= callerMax) {
+    return { ok: false, reason: `Caller ${caller} volume limit hit (${callerMax}/10min)`, code: 'VOLUME_LIMIT' }
+  }
+
+  // 5. Duplicate detection
+  const hash = hashPrompt(prompt)
+  const cached = state.hashCache.get(hash)
+  if (cached && now() - cached.ts < HASH_TTL_MS) {
+    console.log(`[llm-governor] Cache hit for ${caller} (hash ${hash})`)
+    return { ok: true, cached: true, result: cached.result }
+  }
+
+  return { ok: true, cached: false }
+}
+
+/**
+ * Record a completed LLM call (update spend + volume windows).
+ */
+export function governorRecord(
+  caller: string,
+  estimatedCost: number,
+  promptHash?: string,
+  result?: unknown
+) {
+  const t = now()
+  state.lifetimeCount++
+  state.spendWindow.push({ ts: t, cost: estimatedCost })
+  state.volumeWindow.push({ ts: t, caller })
+
+  const callerWindow = pruneWindow(state.callerCounts.get(caller) ?? [], VOLUME_WINDOW_MS)
+  callerWindow.push({ ts: t })
+  state.callerCounts.set(caller, callerWindow)
+
+  if (promptHash && result !== undefined) {
+    state.hashCache.set(promptHash, { result, ts: t })
+  }
+}
+
+/**
+ * Estimate cost for a call (rough).
+ */
+export function estimateCost(model: string, inputChars: number): number {
+  const rate = COST_PER_CALL[model] ?? COST_PER_CALL['default']
+  const estTokens = inputChars / 4
+  return (estTokens / 1000) * rate
+}
+
+/**
+ * Get current governor stats (for /api/status or logging).
+ */
+export function governorStats() {
+  const t = now()
+  const spendArr = pruneWindow(state.spendWindow, SPEND_WINDOW_MS)
+  const volArr = pruneWindow(state.volumeWindow, VOLUME_WINDOW_MS)
+  return {
+    lifetimeCount: state.lifetimeCount,
+    spendLast5Min: spendArr.reduce((s, e) => s + e.cost, 0).toFixed(4),
+    callsLast10Min: volArr.length,
+    cacheSize: state.hashCache.size,
+  }
+}

package/packages/gatsaeng-os/src/lib/neuroscience/energyCycle.ts

@@ -0,0 +1,35 @@
+export function getEnergyRecommendation(
+  currentHour: number,
+  peakHours: number[],
+  energyLogs: { hour: number; level: number }[]
+): {
+  level: 'high' | 'medium' | 'low'
+  recommendation: string
+  suggestedTaskType: string
+} {
+  const recentLogs = energyLogs
+    .filter(l => l.hour === currentHour)
+    .slice(-7)
+
+  const avgEnergy = recentLogs.length
+    ? recentLogs.reduce((sum, l) => sum + l.level, 0) / recentLogs.length
+    : peakHours.includes(currentHour) ? 4 : 2.5
+
+  if (avgEnergy >= 3.5) return {
+    level: 'high',
+    recommendation: '지금이 딥워크 골든타임입니다',
+    suggestedTaskType: '창의적 작업 / 어려운 문제 해결',
+  }
+
+  if (avgEnergy >= 2.5) return {
+    level: 'medium',
+    recommendation: '집중력 유지 가능한 시간입니다',
+    suggestedTaskType: '미팅 / 이메일 / 리뷰',
+  }
+
+  return {
+    level: 'low',
+    recommendation: '에너지 보충이 필요한 시간입니다',
+    suggestedTaskType: '루틴 작업 / 행정 / 휴식',
+  }
+}

package/packages/gatsaeng-os/src/lib/neuroscience/habitStack.ts

@@ -0,0 +1,22 @@
+import type { Routine } from '@/types'
+
+export function buildHabitChain<T extends Routine>(routines: T[]): T[][] {
+  const anchors = routines.filter(r => !r.after_routine_id)
+  const chains: T[][] = []
+
+  for (const anchor of anchors) {
+    const chain: T[] = [anchor]
+    let current = anchor
+
+    while (true) {
+      const next = routines.find(r => r.after_routine_id === current.id)
+      if (!next) break
+      chain.push(next)
+      current = next
+    }
+
+    chains.push(chain)
+  }
+
+  return chains
+}

package/packages/gatsaeng-os/src/lib/neuroscience/scoring.ts

@@ -0,0 +1,32 @@
+import type { ScoreEvent, ScoreResult } from '@/types'
+
+const BASE_SCORES: Record<ScoreEvent['type'], number> = {
+  routine_complete: 10,
+  task_done: 5,
+  task_done_urgent: 15,
+  milestone_complete: 100,
+  review_written: 20,
+  data_uploaded: 10,
+  goal_25pct: 30,
+  goal_50pct: 60,
+  goal_100pct: 200,
+}
+
+export function calculateScore(event: ScoreEvent): ScoreResult {
+  const base = BASE_SCORES[event.type] ?? 0
+
+  // streak multiplier (max 5x)
+  const streak = event.streakCount ?? 0
+  const multiplier = Math.min(1 + streak * 0.05, 5.0)
+  let points = Math.round(base * multiplier)
+
+  // 15% variable bonus (Skinner)
+  let bonus_message: string | null = null
+  if (Math.random() < 0.15) {
+    const bonus = [5, 10, 15, 25][Math.floor(Math.random() * 4)]
+    points += bonus
+    bonus_message = `보너스 +${bonus}점!`
+  }
+
+  return { points, bonus_message }
+}

package/packages/gatsaeng-os/src/lib/routes.ts

@@ -0,0 +1,15 @@
+/** Mapping from entity type to URL prefix */
+export const ENTITY_ROUTES: Record<string, string> = {
+  note: '/notes',
+  task: '/tasks',
+  goal: '/goals',
+  project: '/projects',
+  book: '/books',
+}
+
+/** Build href for an entity */
+export function entityHref(type: string, id: string): string {
+  const prefix = ENTITY_ROUTES[type]
+  if (!prefix) return '/'
+  return `${prefix}/${id}`
+}

package/packages/gatsaeng-os/src/lib/utils.ts

@@ -0,0 +1,6 @@
+import { clsx, type ClassValue } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}

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

@@ -0,0 +1,29 @@
+import path from 'path'
+
+if (!process.env.VAULT_PATH) {
+  throw new Error('VAULT_PATH environment variable is required. Set it to your Obsidian vault GatsaengOS folder.')
+}
+export const VAULT_PATH = process.env.VAULT_PATH
+
+export const FOLDERS = {
+  areas: path.join(VAULT_PATH, 'areas'),
+  goals: path.join(VAULT_PATH, 'goals'),
+  milestones: path.join(VAULT_PATH, 'milestones'),
+  projects: path.join(VAULT_PATH, 'projects'),
+  tasks: path.join(VAULT_PATH, 'tasks'),
+  routines: path.join(VAULT_PATH, 'routines'),
+  reviews: path.join(VAULT_PATH, 'reviews'),
+  sessions: path.join(VAULT_PATH, 'sessions'),
+  timing: path.join(VAULT_PATH, 'timing'),
+  books: path.join(VAULT_PATH, 'books'),
+  calendar: path.join(VAULT_PATH, 'calendar'),
+  notes: path.join(VAULT_PATH, 'notes'),
+  // v2 compat — kept for existing data
+  routineLogs: path.join(VAULT_PATH, 'logs', 'routine'),
+  energyLogs: path.join(VAULT_PATH, 'logs', 'energy'),
+  focusSessions: path.join(VAULT_PATH, 'logs', 'focus'),
+} as const
+
+export const PROFILE_PATH = path.join(VAULT_PATH, 'profile.md')
+
+export type FolderKey = keyof typeof FOLDERS

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

@@ -0,0 +1,84 @@
+import matter from 'gray-matter'
+import type { ZodSchema } from 'zod'
+
+export interface ParsedFile<T> {
+  data: T
+  content: string
+}
+
+function coerceDates(obj: Record<string, unknown>): Record<string, unknown> {
+  const result: Record<string, unknown> = {}
+  for (const [key, value] of Object.entries(obj)) {
+    if (value instanceof Date) {
+      result[key] = value.toISOString()
+    } else if (Array.isArray(value)) {
+      result[key] = value.map(v => v instanceof Date ? v.toISOString() : v)
+    } else {
+      result[key] = value
+    }
+  }
+  return result
+}
+
+export function parseMarkdown<T>(raw: string, schema?: ZodSchema<T>): ParsedFile<T> {
+  const { data, content } = matter(raw)
+  const coerced = coerceDates(data)
+  if (schema) {
+    const parsed = schema.parse(coerced)
+    return { data: parsed, content: content.trim() }
+  }
+  return { data: coerced as T, content: content.trim() }
+}
+
+export function safeParseMarkdown<T>(raw: string, schema: ZodSchema<T>): ParsedFile<T> | null {
+  const { data, content } = matter(raw)
+  const coerced = coerceDates(data)
+  const result = schema.safeParse(coerced)
+  if (result.success) {
+    return { data: result.data, content: content.trim() }
+  }
+  return null
+}
+
+function stripUndefined(obj: unknown): unknown {
+  if (Array.isArray(obj)) return obj.map(stripUndefined)
+  if (obj && typeof obj === 'object' && !(obj instanceof Date)) {
+    const clean: Record<string, unknown> = {}
+    for (const [k, v] of Object.entries(obj)) {
+      if (v !== undefined) clean[k] = stripUndefined(v)
+    }
+    return clean
+  }
+  return obj
+}
+
+export function stringifyMarkdown(data: object, content?: string): string {
+  return matter.stringify(content || '', stripUndefined(data) as Record<string, unknown>)
+}
+
+export function extractBodySections(content: string): Record<string, string> {
+  const sections: Record<string, string> = {}
+  const lines = content.split('\n')
+  let currentSection = ''
+  let currentContent: string[] = []
+
+  for (const line of lines) {
+    const headerMatch = line.match(/^##\s+(.+)$/)
+    if (headerMatch) {
+      if (currentSection) {
+        sections[currentSection] = currentContent.join('\n').trim()
+      }
+      currentSection = headerMatch[1]
+      currentContent = []
+    } else if (currentSection) {
+      currentContent.push(line)
+    }
+  }
+
+  if (currentSection) {
+    sections[currentSection] = currentContent.join('\n').trim()
+  }
+
+  return sections
+}
+