saeeol 1.2.2 → 1.2.4

package/src/cli/cmd/tui/context/theme.tsx

@@ -1,307 +1 @@
-import { CliRenderEvents, type TerminalColors } from "@opentui/core"
-import path from "path"
-import { createEffect, createMemo, onCleanup, onMount } from "solid-js"
-import { createSimpleContext } from "./helper"
-import { Glob } from "@saeeol/core/util/glob"
-import { useKV } from "./kv"
-import { useRenderer } from "@opentui/solid"
-import { createStore, produce } from "solid-js/store"
-import { Global } from "@saeeol/core/global"
-import { Filesystem } from "@/util/filesystem"
-import { useTuiConfig } from "./tui-config"
-import { isRecord } from "@/util/record"
-import { selectedForeground, tint } from "./theme/theme-types"
-import type { ThemeJson, Theme } from "./theme/theme-types"
-import { DEFAULT_THEMES, isValidTheme } from "./theme/theme-themes"
-import { resolveTheme } from "./theme/theme-resolve"
-import { generateSystem } from "./theme/theme-system"
-import { generateSyntax, generateSubtleSyntax } from "./theme/theme-syntax"
-
-export { selectedForeground, tint }
-export type { ThemeJson }
-export { DEFAULT_THEMES }
-export { resolveTheme }
-
-type State = {
-  themes: Record<string, ThemeJson>
-  mode: "dark" | "light"
-  lock: "dark" | "light" | undefined
-  active: string
-  ready: boolean
-}
-
-const pluginThemes: Record<string, ThemeJson> = {}
-let customThemes: Record<string, ThemeJson> = {}
-let systemTheme: ThemeJson | undefined
-
-function listThemes() {
-  const themes = {
-    ...DEFAULT_THEMES,
-    ...pluginThemes,
-    ...customThemes,
-  }
-  if (!systemTheme) return themes
-  return {
-    ...themes,
-    system: systemTheme,
-  }
-}
-
-function syncThemes() {
-  setStore("themes", listThemes())
-}
-
-const [store, setStore] = createStore<State>({
-  themes: listThemes(),
-  mode: "dark",
-  lock: undefined,
-  active: "saeeol",
-  ready: false,
-})
-
-export function allThemes() {
-  return store.themes
-}
-
-function isTheme(theme: unknown): theme is ThemeJson {
-  if (!isRecord(theme)) return false
-  if (!isRecord(theme.theme)) return false
-  return true
-}
-
-export function hasTheme(name: string) {
-  if (!name) return false
-  return allThemes()[name] !== undefined
-}
-
-export function addTheme(name: string, theme: unknown) {
-  if (!name) return false
-  if (!isTheme(theme)) return false
-  if (hasTheme(name)) return false
-  pluginThemes[name] = theme
-  syncThemes()
-  return true
-}
-
-export function upsertTheme(name: string, theme: unknown) {
-  if (!name) return false
-  if (!isTheme(theme)) return false
-  if (customThemes[name] !== undefined) {
-    customThemes[name] = theme
-  } else {
-    pluginThemes[name] = theme
-  }
-  syncThemes()
-  return true
-}
-
-export const { use: useTheme, provider: ThemeProvider } = createSimpleContext({
-  name: "Theme",
-  init: (props: { mode: "dark" | "light" }) => {
-    const renderer = useRenderer()
-    const config = useTuiConfig()
-    const kv = useKV()
-    const pick = (value: unknown) => {
-      if (value === "dark" || value === "light") return value
-      return
-    }
-
-    setStore(
-      produce((draft) => {
-        const lock = pick(kv.get("theme_mode_lock"))
-        const mode = lock ?? pick(renderer.themeMode) ?? props.mode
-        if (!lock && pick(kv.get("theme_mode")) !== undefined) {
-          kv.set("theme_mode", undefined)
-        }
-        draft.mode = mode
-        draft.lock = lock
-        const active = config.theme ?? kv.get("theme", "saeeol")
-        draft.active = typeof active === "string" ? active : "saeeol"
-        draft.ready = false
-      }),
-    )
-
-    createEffect(() => {
-      const theme = config.theme
-      if (theme) setStore("active", theme)
-    })
-
-    function init() {
-      void Promise.allSettled([
-        resolveSystemTheme(store.mode),
-        getCustomThemes()
-          .then((custom) => {
-            customThemes = custom
-            syncThemes()
-          })
-          .catch(() => {
-            setStore("active", "saeeol")
-          }),
-      ]).finally(() => {
-        setStore("ready", true)
-      })
-    }
-
-    onMount(init)
-
-    function resolveSystemTheme(mode: "dark" | "light" = store.mode) {
-      return renderer
-        .getPalette({
-          size: 16,
-        })
-        .then((colors: TerminalColors) => {
-          if (!colors.palette[0]) {
-            systemTheme = undefined
-            syncThemes()
-            if (store.active === "system") {
-              setStore("active", "saeeol")
-            }
-            return
-          }
-          systemTheme = generateSystem(colors, mode)
-          syncThemes()
-        })
-        .catch(() => {
-          systemTheme = undefined
-          syncThemes()
-          if (store.active === "system") {
-            setStore("active", "saeeol")
-          }
-        })
-    }
-
-    function apply(mode: "dark" | "light") {
-      if (store.lock !== undefined) kv.set("theme_mode", mode)
-      if (store.mode === mode) return
-      setStore("mode", mode)
-      renderer.clearPaletteCache()
-      void resolveSystemTheme(mode)
-    }
-
-    function pin(mode: "dark" | "light" = store.mode) {
-      setStore("lock", mode)
-      kv.set("theme_mode_lock", mode)
-      apply(mode)
-    }
-
-    function free() {
-      setStore("lock", undefined)
-      kv.set("theme_mode_lock", undefined)
-      kv.set("theme_mode", undefined)
-      const mode = renderer.themeMode
-      if (mode) apply(mode)
-    }
-
-    const handle = (mode: "dark" | "light") => {
-      if (store.lock) return
-      apply(mode)
-    }
-    renderer.on(CliRenderEvents.THEME_MODE, handle)
-
-    const refresh = () => {
-      renderer.clearPaletteCache()
-      init()
-    }
-    process.on("SIGUSR2", refresh)
-
-    onCleanup(() => {
-      renderer.off(CliRenderEvents.THEME_MODE, handle)
-      process.off("SIGUSR2", refresh)
-    })
-    const values = createMemo(() => {
-      const active = store.themes[store.active]
-      if (active) {
-        return resolveTheme(active, store.mode)
-      }
-
-      const saved = kv.get("theme")
-      if (typeof saved === "string") {
-        const theme = store.themes[saved]
-        if (theme) {
-          return resolveTheme(theme, store.mode)
-        }
-      }
-
-      return resolveTheme(store.themes.saeeol, store.mode)
-    })
-
-    createEffect(() => {
-      renderer.setBackgroundColor(values().background)
-    })
-
-    const syntax = createMemo(() => generateSyntax(values()))
-    const subtleSyntax = createMemo(() => generateSubtleSyntax(values()))
-    return {
-      theme: new Proxy({} as Theme, {
-        get(_target, prop) {
-          // @ts-expect-error
-          return values()[prop]
-        },
-      }),
-      get selected() {
-        return store.active
-      },
-      all() {
-        return allThemes()
-      },
-      has(name: string) {
-        return hasTheme(name)
-      },
-      syntax,
-      subtleSyntax,
-      mode() {
-        return store.mode
-      },
-      locked() {
-        return store.lock !== undefined
-      },
-      lock() {
-        pin(store.mode)
-      },
-      unlock() {
-        free()
-      },
-      setMode(mode: "dark" | "light") {
-        pin(mode)
-      },
-      set(theme: string) {
-        if (!hasTheme(theme)) return false
-        setStore("active", theme)
-        kv.set("theme", theme)
-        return true
-      },
-      get ready() {
-        return store.ready
-      },
-    }
-  },
-})
-
-async function getCustomThemes() {
-  const directories = [
-    Global.Path.config,
-    ...(await Array.fromAsync(
-      Filesystem.up({
-        targets: [".saeeol", ".saeeol"],
-        start: process.cwd(),
-      }),
-    )),
-  ]
-
-  const result: Record<string, ThemeJson> = {}
-  for (const dir of directories) {
-    for (const item of await Glob.scan("themes/*.json", {
-      cwd: dir,
-      absolute: true,
-      dot: true,
-      symlink: true,
-    })) {
-      const name = path.basename(item, ".json")
-      if (name in DEFAULT_THEMES) continue
-      const json = await Filesystem.readJson(item).catch(() => null)
-      if (!isValidTheme(json)) continue
-      result[name] = json
-    }
-  }
-  return result
-}
+export * from "./app/theme"

package/src/cli/cmd/tui/context/tui-config.tsx

@@ -1,9 +1 @@
-import { TuiConfig } from "@/cli/cmd/tui/config/tui"
-import { createSimpleContext } from "./helper"
-
-export const { use: useTuiConfig, provider: TuiConfigProvider } = createSimpleContext({
-  name: "TuiConfig",
-  init: (props: { config: TuiConfig.Info }) => {
-    return props.config
-  },
-})
+export * from "./app/tui-config"

package/src/ltm/pipeline.ts

@@ -11,11 +11,13 @@ import * as Procedural from "@/ltm/memory/procedural"
 import * as Scheduler from "@/ltm/scheduler"
 import type { LTMConfig, LLMBakeParams } from "@/ltm/types"
 import { LTMEvent } from "@/ltm/events"
+import { SessionEvent } from "@/session/core/session-types"
 
 const log = Log.create({ service: "ltm/pipeline" })
 
 let running = false
 let config: LTMConfig | undefined
+let unsubscribers: Array<() => void> = []
 
 // ── 파이프라인 수명 ──
 
@@ -57,6 +59,9 @@ export async function start(cfg: LTMConfig, bake: LLMBakeParams): Promise<void>
     log.info("trimmed memories to max", { removed: toRemove.length })
   }
 
+  // BusEvent 구독 바인딩
+  bindSubscriptions()
+
   log.info("pipeline started", { memoryCount: await Store.count() })
 }
 
@@ -64,6 +69,13 @@ export async function start(cfg: LTMConfig, bake: LLMBakeParams): Promise<void>
 export async function stop(): Promise<void> {
   if (!running) return
   running = false
+
+  // 구독 해제
+  for (const unsub of unsubscribers) {
+    try { unsub() } catch { /* ignore */ }
+  }
+  unsubscribers = []
+
   await Embedder.stop()
   config = undefined
   log.info("pipeline stopped")
@@ -74,7 +86,90 @@ export function isActive(): boolean {
   return running
 }
 
-// ── 이벤트 핸들러 ──
+// ── BusEvent 구독 바인딩 ──
+
+function bindSubscriptions() {
+  if (!config) return
+
+  // 1. 세션 diff → 에피소드 기억 (코드 변경 후 AI 응답 완료 시)
+  const unsubDiff = Bus.subscribe(SessionEvent.Diff, async (event) => {
+    if (!running || !config?.episodic.enabled) return
+
+    const sessionID = event.properties.sessionID
+    // diff 이벤트는 assistant 응답 후 세션 상태가 업데이트될 때 발생
+    // 사용자 메시지와 assistant 응답을 모두 포함할 수 있는 컨텍스트로 처리
+    const diffs = event.properties.diff
+    if (!diffs || diffs.length === 0) return
+
+    const summary = `code changes: ${diffs.map((d) => `${d.filePath} (${d.status})`).join(", ")}`
+    try {
+      const vector = await Embedder.embedOne(summary)
+      const memory = {
+        id: `epi:${sessionID}:${Date.now()}`,
+        type: "episodic" as const,
+        content: summary.slice(0, 500),
+        summary,
+        vector,
+        metadata: {
+          source: `session:${sessionID}`,
+          timestamp: Date.now(),
+          sessionID,
+          tags: ["code-change"],
+        },
+      }
+      await Store.upsert(memory)
+      void Bus.publish(LTMEvent.MemoryStored, {
+        id: memory.id,
+        type: memory.type,
+        source: memory.metadata.source,
+      })
+    } catch (e) {
+      log.error("failed to store session diff memory", { error: e })
+    }
+  })
+  unsubscribers.push(unsubDiff)
+
+  // 2. 세션 에러 → 에피소드 기억 (문제/해결 추적)
+  const unsubError = Bus.subscribe(SessionEvent.Error, async (event) => {
+    if (!running || !config?.episodic.enabled) return
+    const sessionID = event.properties.sessionID
+    if (!sessionID) return
+
+    const err = event.properties.error
+    if (!err) return
+
+    const summary = `error in session: ${typeof err === "object" ? JSON.stringify(err).slice(0, 200) : String(err).slice(0, 200)}`
+    try {
+      const vector = await Embedder.embedOne(summary)
+      const memory = {
+        id: `epi:err:${sessionID}:${Date.now()}`,
+        type: "episodic" as const,
+        content: summary.slice(0, 500),
+        summary,
+        vector,
+        metadata: {
+          source: `session:${sessionID}`,
+          timestamp: Date.now(),
+          sessionID,
+          tags: ["error"],
+        },
+      }
+      await Store.upsert(memory)
+      void Bus.publish(LTMEvent.MemoryStored, {
+        id: memory.id,
+        type: memory.type,
+        source: memory.metadata.source,
+      })
+    } catch (e) {
+      log.error("failed to store error memory", { error: e })
+    }
+  })
+  unsubscribers.push(unsubError)
+
+  log.info("bus subscriptions bound", { count: unsubscribers.length })
+}
+
+// ── 직접 호출 핸들러 (외부에서 명시적으로 호출) ──
 
 /** 대화 메시지 → 에피소드 기억 */
 export async function onMessageCompleted(
@@ -104,6 +199,13 @@ export async function onFileChanged(
 ): Promise<void> {
   if (!running || !config?.semantic.enabled || !config.semantic.indexOnFileChange) return
 
+  // VRAM 스케줄러 확인 — 임베딩 작업 가능한지
+  const canRun = await Scheduler.canRunEmbedding()
+  if (!canRun) {
+    log.info("skipping file indexing — VRAM budget exceeded", { filePath })
+    return
+  }
+
   // 파일을 청크로 분할 (간단한 줄 기반)
   const lines = content.split("\n")
   const chunkSize = 50

package/test/server/contract.test.ts

@@ -0,0 +1,249 @@
+/**
+ * contract.test.ts — SAEEOL 서버 계약 테스트
+ *
+ * closebook 패턴 기반:
+ * - response-conformance: Effect Schema로 응답 바디 적합성 검사
+ * - consumer-contract: SDK/클라이언트가 기대하는 API 응답 스키마 검증
+ * - stateful-api-testing: 세션 생성 → 프롬프트 → 메시지 조회 → 삭제 순차 테스트
+ *
+ * Hono app.request()로 실제 HTTP 서버 없이 테스트.
+ * Bun test + Effect + zod 검증.
+ */
+
+import { afterEach, describe, expect } from "bun:test"
+import { Effect } from "effect"
+import { Flag } from "@saeeol/core/flag/flag"
+import { Server } from "../../src/server/server"
+import { resetDatabase } from "../fixture/db"
+import { disposeAllInstances, tmpdir } from "../fixture/fixture"
+import { it } from "../lib/effect"
+import * as Log from "@saeeol/core/util/log"
+import { z } from "zod"
+
+void Log.init({ print: false })
+
+const original = Flag.SAEEOL_EXPERIMENTAL_HTTPAPI
+
+function app(experimental = true) {
+	Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = experimental
+	return experimental ? Server.Default().app : Server.Legacy().app
+}
+
+afterEach(async () => {
+	Flag.SAEEOL_EXPERIMENTAL_HTTPAPI = original
+	await disposeAllInstances()
+})
+
+// ── Zod 스키마 (계약: 클라이언트가 기대하는 응답 형태) ──
+
+const HealthSchema = z.object({
+	healthy: z.boolean(),
+	version: z.string(),
+})
+
+const ConfigSchema = z.object({
+	model: z.string().optional(),
+	username: z.string().optional(),
+}).passthrough()
+
+const SessionListSchema = z.array(z.object({
+	id: z.string(),
+	title: z.string().optional(),
+	createdAt: z.number().optional(),
+}).passthrough())
+
+const SessionCreateSchema = z.object({
+	id: z.string(),
+}).passthrough()
+
+const AgentListSchema = z.array(z.unknown())
+
+const ErrorResponseSchema = z.object({
+	error: z.string().or(z.record(z.unknown())),
+}).passthrough()
+
+// ── 응답 적합성 검증 (closebook: response-conformance) ──
+
+function checkConformance<T extends z.ZodType>(
+	body: unknown,
+	status: number,
+	schema: T,
+	allowedStatuses: number[] = [200],
+): { ok: boolean; violations: string[] } {
+	const violations: string[] = []
+
+	if (!allowedStatuses.includes(status)) {
+		violations.push(`status: expected ${allowedStatuses.join("/")}, got ${status}`)
+	}
+
+	const parsed = schema.safeParse(body)
+	if (!parsed.success) {
+		for (const issue of parsed.error.issues) {
+			violations.push(`${issue.path.join(".") || "(root)"}: ${issue.message}`)
+		}
+	}
+
+	return { ok: violations.length === 0, violations }
+}
+
+// ── 테스트 ──
+
+describe("SAEEOL server contract tests", () => {
+	describe("GET /global/health", () => {
+		it.live("returns valid health response (legacy)", () =>
+			Effect.gen(function* () {
+				const res = yield* Effect.promise(async () => await app(false).request("/global/health"))
+				const body = yield* Effect.promise(async () => await res.json())
+				expect(res.status).toBe(200)
+				const { ok, violations } = checkConformance(body, res.status, HealthSchema)
+				expect(ok).toBe(true)
+				if (!ok) console.error("Health violations:", violations)
+			}),
+		)
+
+		it.live("returns valid health response (experimental)", () =>
+			Effect.gen(function* () {
+				const res = yield* Effect.promise(async () => await app(true).request("/global/health"))
+				const body = yield* Effect.promise(async () => await res.json())
+				expect(res.status).toBe(200)
+				const { ok, violations } = checkConformance(body, res.status, HealthSchema)
+				expect(ok).toBe(true)
+				if (!ok) console.error("Health violations:", violations)
+			}),
+		)
+	})
+
+	describe("GET /global/config", () => {
+		it.live("returns valid config response", () =>
+			Effect.gen(function* () {
+				await using tmp = yield* Effect.promise(() => tmpdir({ config: {} }))
+				const res = yield* Effect.promise(
+					async () => await app(false).request("/global/config", {
+						headers: { "x-saeeol-directory": tmp.path },
+					}),
+				)
+				const body = yield* Effect.promise(async () => await res.json())
+				const { ok, violations } = checkConformance(body, res.status, ConfigSchema)
+				expect(ok).toBe(true)
+				if (!ok) console.error("Config violations:", violations)
+			}),
+		)
+	})
+
+	describe("GET /agent", () => {
+		it.live("returns agent list", () =>
+			Effect.gen(function* () {
+				await using tmp = yield* Effect.promise(() => tmpdir({ config: {} }))
+				const res = yield* Effect.promise(
+					async () => await app(false).request("/agent", {
+						headers: { "x-saeeol-directory": tmp.path },
+					}),
+				)
+				const body = yield* Effect.promise(async () => await res.json())
+				const { ok, violations } = checkConformance(body, res.status, AgentListSchema)
+				expect(ok).toBe(true)
+				if (!ok) console.error("Agent violations:", violations)
+			}),
+		)
+	})
+
+	describe("session CRUD", () => {
+		it.live("creates and lists sessions", () =>
+			Effect.gen(function* () {
+				await using tmp = yield* Effect.promise(() => tmpdir({ git: true, config: {} }))
+				const headers = { "x-saeeol-directory": tmp.path, "Content-Type": "application/json" }
+
+				// Create session
+				const createRes = yield* Effect.promise(
+					async () => await app(false).request("/session", {
+						method: "POST",
+						headers,
+						body: JSON.stringify({ title: "contract-test" }),
+					}),
+				)
+				const createBody = yield* Effect.promise(async () => await createRes.json())
+				const { ok: createOk, violations: createViolations } = checkConformance(
+					createBody,
+					createRes.status,
+					SessionCreateSchema,
+				)
+				expect(createOk).toBe(true)
+				if (!createOk) console.error("Session create violations:", createViolations)
+
+				// List sessions
+				const listRes = yield* Effect.promise(
+					async () => await app(false).request("/session", { headers }),
+				)
+				const listBody = yield* Effect.promise(async () => await listRes.json())
+				const { ok: listOk, violations: listViolations } = checkConformance(
+					listBody,
+					listRes.status,
+					SessionListSchema,
+				)
+				expect(listOk).toBe(true)
+				if (!listOk) console.error("Session list violations:", listViolations)
+			}),
+		)
+	})
+
+	describe("unknown route", () => {
+		it.live("returns error for unknown endpoints", () =>
+			Effect.gen(function* () {
+				const res = yield* Effect.promise(async () => await app(false).request("/nonexistent"))
+				expect(res.status).toBe(404)
+			}),
+		)
+	})
+
+	// ── 계약 파일 생성 (closebook: consumer-contract) ──
+
+	describe("pact artifact generation", () => {
+		it.live("collects verified interactions into contract", () =>
+			Effect.gen(function* () {
+				await using tmp = yield* Effect.promise(() => tmpdir({ config: {} }))
+				const headers = { "x-saeeol-directory": tmp.path }
+				const interactions = []
+
+				// Health 인터랙션
+				const healthRes = yield* Effect.promise(
+					async () => await app(false).request("/global/health"),
+				)
+				const healthBody = yield* Effect.promise(async () => await healthRes.json())
+				interactions.push({
+					description: "health check",
+					providerStates: [],
+					request: { method: "GET", path: "/global/health" },
+					response: { status: healthRes.status, body: healthBody },
+				})
+
+				// Config 인터랙션
+				const configRes = yield* Effect.promise(
+					async () => await app(false).request("/global/config", { headers }),
+				)
+				const configBody = yield* Effect.promise(async () => await configRes.json())
+				interactions.push({
+					description: "global config",
+					providerStates: [],
+					request: { method: "GET", path: "/global/config" },
+					response: { status: configRes.status, body: configBody },
+				})
+
+				// 계약 파일 검증
+				const pact = {
+					consumer: { name: "saeeol-vscode" },
+					provider: { name: "saeeol-server" },
+					interactions,
+					metadata: { version: "1.0.0" },
+				}
+
+				expect(pact.interactions.length).toBeGreaterThanOrEqual(2)
+				for (const ix of pact.interactions) {
+					expect(ix).toHaveProperty("description")
+					expect(ix).toHaveProperty("request")
+					expect(ix).toHaveProperty("response")
+					expect(ix.response.status).toBeLessThan(500)
+				}
+			}),
+		)
+	})
+})