saeeol 1.2.3 → 1.2.4

package/bin/saeeol.cjs

@@ -175,13 +175,29 @@ function findBinary(startDir) {
 }
 
 const resolved = findBinary(scriptDir)
-if (!resolved) {
-  console.error(
-    "It seems that your package manager failed to install the right version of the SAEEOL CLI for your platform. You can try manually installing " +
-      names.map((n) => `\"${n}\"`).join(" or ") +
-      " package",
-  )
-  process.exit(1)
+if (resolved) {
+  run(resolved)
 }
 
-run(resolved)
+// Fallback: run source with bun if available
+const indexPath = path.join(scriptDir, "src", "index.ts")
+if (fs.existsSync(indexPath)) {
+  const bunExe = process.platform === "win32" ? "bun.exe" : "bun"
+  try {
+    const which = childProcess.spawnSync(bunExe, ["--version"], { encoding: "utf8", timeout: 3000 })
+    if (which.status === 0) {
+      const result = childProcess.spawnSync(bunExe, [
+        "run", "--conditions=browser", indexPath, ...process.argv.slice(2)
+      ], { stdio: "inherit" })
+      const code = typeof result.status === "number" ? result.status : 0
+      process.exit(code)
+    }
+  } catch {}
+}
+
+console.error(
+  "It seems that your package manager failed to install the right version of the SAEEOL CLI for your platform. You can try manually installing " +
+    names.map((n) => `\"${n}\"`).join(" or ") +
+    " package, or install bun (https://bun.sh) to run from source",
+)
+process.exit(1)

package/package.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://json.schemastore.org/package.json",
-  "version": "1.2.3",
+  "version": "1.2.4",
   "name": "saeeol",
   "type": "module",
   "license": "Apache-2.0",

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