saeeol 1.4.0 → 1.4.2

package/package.json

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

package/src/provider/provider-schemas.ts

@@ -35,7 +35,7 @@ export const Info = Schema.Struct({
 export type Info = Types.DeepMutable<Schema.Schema.Type<typeof Info>>
 
 const DefaultModelIDs = Schema.Record(Schema.String, Schema.String)
-export const ListResult = Schema.Struct({ all: Schema.Array(Info), default: DefaultModelIDs, connected: Schema.Array(Schema.String), failed: Schema.Array(Schema.String) }).pipe(withStatics((s) => ({ zod: zod(s) })))
+export const ListResult = Schema.Struct({ all: Schema.Array(Info), default: DefaultModelIDs, connected: Schema.Array(Schema.String), failed: Schema.Array(Schema.String), gateway: Schema.NullOr(Info) }).pipe(withStatics((s) => ({ zod: zod(s) })))
 export type ListResult = Types.DeepMutable<Schema.Schema.Type<typeof ListResult>>
 export const ConfigProvidersResult = Schema.Struct({ providers: Schema.Array(Info), default: DefaultModelIDs }).pipe(withStatics((s) => ({ zod: zod(s) })))
 export type ConfigProvidersResult = Types.DeepMutable<Schema.Schema.Type<typeof ConfigProvidersResult>>

package/src/server/routes/instance/httpapi/groups/ltm.ts

@@ -0,0 +1,93 @@
+/**
+ * groups/ltm.ts — LTM (Long-Term Memory) HTTP API group
+ *
+ * 외부 앱(chowriter 등)이 saeeol LTM에 기억을 저장/검색하는 엔드포인트.
+ */
+
+import { Schema } from "effect"
+import { HttpApi, HttpApiEndpoint, HttpApiGroup, OpenApi } from "effect/unstable/httpapi"
+import { Authorization } from "../middleware/authorization"
+import { InstanceContextMiddleware } from "../middleware/instance-context"
+import { WorkspaceRoutingMiddleware } from "../middleware/workspace-routing"
+import { described } from "./metadata"
+
+const root = "/ltm"
+
+// Request schemas
+const IngestPayload = Schema.Struct({
+  type: Schema.Literal("episodic", "semantic", "procedural"),
+  content: Schema.String,
+  summary: Schema.String,
+  projectID: Schema.optional(Schema.String),
+  sessionID: Schema.optional(Schema.String),
+  tags: Schema.optional(Schema.mutable(Schema.Array(Schema.String))),
+})
+
+const SearchPayload = Schema.Struct({
+  query: Schema.String,
+  topK: Schema.optional(Schema.Number),
+  minScore: Schema.optional(Schema.Number),
+  type: Schema.optional(Schema.Literal("episodic", "semantic", "procedural")),
+  projectID: Schema.optional(Schema.String),
+})
+
+const DeletePayload = Schema.Struct({
+  ids: Schema.mutable(Schema.Array(Schema.String)),
+})
+
+// Response schemas
+const MemoryEntry = Schema.Struct({
+  id: Schema.String,
+  type: Schema.String,
+  summary: Schema.String,
+  content: Schema.String,
+  score: Schema.optional(Schema.Number),
+  metadata: Schema.Struct({
+    source: Schema.String,
+    timestamp: Schema.Number,
+    projectID: Schema.optional(Schema.String),
+    tags: Schema.mutable(Schema.Array(Schema.String)),
+  }),
+})
+
+const IngestResponse = Schema.Struct({
+  id: Schema.String,
+  success: Schema.Boolean,
+})
+
+const SearchResponse = Schema.Struct({
+  memories: Schema.mutable(Schema.Array(MemoryEntry)),
+  count: Schema.Number,
+})
+
+const DeleteResponse = Schema.Struct({
+  removed: Schema.Number,
+})
+
+export const LTMHttpApi = HttpApi.make("ltm")
+  .add(
+    HttpApiGroup.make(root, "ltm")
+      .add(
+        HttpApiEndpoint.post("ingest", `${root}/ingest`)
+          .setPayload(IngestPayload)
+          .addSuccess(IngestResponse)
+          .annotateMerge(OpenApi.annotations({ identifier: "ltm.ingest", summary: "Store a memory in LTM" })),
+      )
+      .add(
+        HttpApiEndpoint.post("search", `${root}/search`)
+          .setPayload(SearchPayload)
+          .addSuccess(SearchResponse)
+          .annotateMerge(OpenApi.annotations({ identifier: "ltm.search", summary: "Search LTM memories by query" })),
+      )
+      .add(
+        HttpApiEndpoint.post("delete", `${root}/delete`)
+          .setPayload(DeletePayload)
+          .addSuccess(DeleteResponse)
+          .annotateMerge(OpenApi.annotations({ identifier: "ltm.delete", summary: "Delete LTM memories by ID" })),
+      )
+      .add(
+        HttpApiEndpoint.get("status", `${root}/status`)
+          .addSuccess(Schema.Struct({ enabled: Schema.Boolean, memoryCount: Schema.Number }))
+          .annotateMerge(OpenApi.annotations({ identifier: "ltm.status", summary: "Get LTM status" })),
+      ),
+  )

package/src/server/routes/instance/httpapi/handlers/ltm.ts

@@ -0,0 +1,118 @@
+/**
+ * handlers/ltm.ts — LTM HTTP API handlers
+ *
+ * 외부 앱이 saeeol LTM에 기억을 저장/검색/삭제.
+ * 임베딩은 로컬 서버가 처리, 클라이언트는 텍스트만 보냄.
+ */
+
+import { Effect } from "effect"
+import * as Log from "@saeeol/core/util/log"
+import * as HttpApiBuilder from "effect/unstable/httpapi"
+import * as LTM from "@/ltm"
+import * as Embedder from "@/provider/local/embedder"
+import { LTMHttpApi } from "../groups/ltm"
+
+const log = Log.create({ service: "server/handlers/ltm" })
+
+export const ltmHandlers = HttpApiBuilder.group(LTMHttpApi, "ltm", (handlers) =>
+  Effect.gen(function* () {
+    const config = LTM.Config.DEFAULT_LTM_CONFIG
+
+    return handlers
+      .handle("ingest", ({ payload }) =>
+        Effect.gen(function* () {
+          if (!config.enabled) {
+            yield* log.info("LTM ingest skipped — disabled")
+            return HttpApiBuilder.fail({ status: 400 as const, body: { message: "LTM is disabled" } })
+          }
+
+          const embedderStatus = Embedder.status()
+          if (!embedderStatus || embedderStatus.status !== "running") {
+            yield* log.info("LTM ingest skipped — embedder not running")
+            return HttpApiBuilder.fail({ status: 503 as const, body: { message: "Embedding server not running" } })
+          }
+
+          const vector = yield* Effect.tryPromise(() => Embedder.embedOne(payload.summary))
+          const id = `${payload.type[0]}:${payload.projectID ?? "global"}:${Date.now()}`
+          const memory: LTM.Memory = {
+            id,
+            type: payload.type,
+            content: payload.content.slice(0, 2000),
+            summary: payload.summary,
+            vector,
+            metadata: {
+              source: `external:${payload.projectID ?? "unknown"}`,
+              timestamp: Date.now(),
+              projectID: payload.projectID,
+              sessionID: payload.sessionID,
+              tags: payload.tags ?? [],
+            },
+          }
+
+          yield* Effect.tryPromise(() => LTM.Store.upsert(memory))
+          yield* log.info("LTM ingest", { id, type: payload.type })
+
+          return { id, success: true }
+        }),
+      )
+      .handle("search", ({ payload }) =>
+        Effect.gen(function* () {
+          if (!config.enabled) {
+            return { memories: [], count: 0 }
+          }
+
+          const embedderStatus = Embedder.status()
+          if (!embedderStatus || embedderStatus.status !== "running") {
+            return { memories: [], count: 0 }
+          }
+
+          const vector = yield* Effect.tryPromise(() => Embedder.embedOne(payload.query))
+          const memories = yield* Effect.tryPromise(() =>
+            LTM.Store.search(vector, {
+              topK: payload.topK ?? config.retrieval.topK,
+              minScore: payload.minScore ?? config.retrieval.minScore,
+              type: payload.type,
+            }),
+          )
+
+          // projectID 필터 (store 레벨에서 안 되면 여기서)
+          const filtered = payload.projectID
+            ? memories.filter((m) => m.metadata.projectID === payload.projectID)
+            : memories
+
+          // vector는 응답에서 제거 (용량 절약)
+          const lean = filtered.map((m) => ({
+            id: m.id,
+            type: m.type,
+            summary: m.summary,
+            content: m.content,
+            score: m.score,
+            metadata: {
+              source: m.metadata.source,
+              timestamp: m.metadata.timestamp,
+              projectID: m.metadata.projectID,
+              tags: m.metadata.tags,
+            },
+          }))
+
+          return { memories: lean, count: lean.length }
+        }),
+      )
+      .handle("delete", ({ payload }) =>
+        Effect.gen(function* () {
+          yield* Effect.tryPromise(() => LTM.Store.remove(payload.ids))
+          return { removed: payload.ids.length }
+        }),
+      )
+      .handle("status", () =>
+        Effect.gen(function* () {
+          const embedder = Embedder.status()
+          const count = yield* Effect.tryPromise(() => LTM.Store.count())
+          return {
+            enabled: config.enabled && embedder?.status === "running",
+            memoryCount: count,
+          }
+        }),
+      )
+  }),
+)

package/src/server/routes/instance/httpapi/handlers/provider.ts

@@ -39,10 +39,11 @@ export const providerHandlers = HttpApiBuilder.group(InstanceHttpApi, "provider"
         (item, id) => Object.keys(item.models).length > 0 || id in connected || failedSet.has(id),
       )
       return {
-        all: Object.values(validProviders),
+        all: Object.values(validProviders).filter((p) => p.id !== "saeeol"),
         default: Provider.defaultModelIDs(pickBy(validProviders, (item) => Object.keys(item.models ?? {}).length > 0)),
-        connected: Object.keys(connected),
-        failed,
+        connected: Object.keys(connected).filter((id) => id !== "saeeol"),
+        failed: failed.filter((id) => id !== "saeeol"),
+        gateway: validProviders["saeeol"] ?? null,
       }
     })
 

package/src/server/routes/instance/index.ts

@@ -27,7 +27,9 @@ import { EventRoutes } from "./event"
 import { SyncRoutes } from "./sync"
 import { InstanceMiddleware } from "./middleware"
 import { jsonRequest } from "./trace"
-import { register as registerSaeeolRoutes } from "@/saeeol/server/instance" 
+import { register as registerSaeeolRoutes } from "@/saeeol/server/instance"
+import * as LTM from "@/ltm"
+import * as Embedder from "@/provider/local/embedder"
 
 export const InstanceRoutes = (upgrade: UpgradeWebSocket): Hono => {
   const app = new Hono()
@@ -47,6 +49,99 @@ export const InstanceRoutes = (upgrade: UpgradeWebSocket): Hono => {
     .route("/", EventRoutes())
     .route("/mcp", McpRoutes())
     .route("/tui", TuiRoutes())
+    // ── LTM (Long-Term Memory) ──
+    .post(
+      "/ltm/ingest",
+      describeRoute({
+        summary: "Store a memory in LTM",
+        operationId: "ltm.ingest",
+        responses: { 200: { description: "Memory stored" } },
+      }),
+      async (c) => {
+        const body = await c.req.json<{ type: "episodic" | "semantic" | "procedural"; content: string; summary: string; projectID?: string; sessionID?: string; tags?: string[] }>()
+        const embedderStatus = Embedder.status()
+        if (!embedderStatus || embedderStatus.status !== "running") {
+          return c.json({ error: "Embedding server not running" }, 503)
+        }
+        const vector = await Embedder.embedOne(body.summary)
+        const id = `${body.type[0]}:${body.projectID ?? "global"}:${Date.now()}`
+        const memory: LTM.Memory = {
+          id,
+          type: body.type,
+          content: body.content.slice(0, 2000),
+          summary: body.summary,
+          vector,
+          metadata: {
+            source: `external:${body.projectID ?? "unknown"}`,
+            timestamp: Date.now(),
+            projectID: body.projectID,
+            sessionID: body.sessionID,
+            tags: body.tags ?? [],
+          },
+        }
+        await LTM.Store.upsert(memory)
+        return c.json({ id, success: true })
+      },
+    )
+    .post(
+      "/ltm/search",
+      describeRoute({
+        summary: "Search LTM memories by query",
+        operationId: "ltm.search",
+        responses: { 200: { description: "Search results" } },
+      }),
+      async (c) => {
+        const body = await c.req.json<{ query: string; topK?: number; minScore?: number; type?: "episodic" | "semantic" | "procedural"; projectID?: string }>()
+        const embedderStatus = Embedder.status()
+        if (!embedderStatus || embedderStatus.status !== "running") {
+          return c.json({ memories: [], count: 0 })
+        }
+        const vector = await Embedder.embedOne(body.query)
+        const memories = await LTM.Store.search(vector, {
+          topK: body.topK ?? 5,
+          minScore: body.minScore ?? 0.7,
+          type: body.type,
+        })
+        const filtered = body.projectID
+          ? memories.filter((m) => m.metadata.projectID === body.projectID)
+          : memories
+        const lean = filtered.map((m) => ({
+          id: m.id,
+          type: m.type,
+          summary: m.summary,
+          content: m.content,
+          score: m.score,
+          metadata: { source: m.metadata.source, timestamp: m.metadata.timestamp, projectID: m.metadata.projectID, tags: m.metadata.tags },
+        }))
+        return c.json({ memories: lean, count: lean.length })
+      },
+    )
+    .post(
+      "/ltm/delete",
+      describeRoute({
+        summary: "Delete LTM memories by ID",
+        operationId: "ltm.delete",
+        responses: { 200: { description: "Deleted" } },
+      }),
+      async (c) => {
+        const body = await c.req.json<{ ids: string[] }>()
+        await LTM.Store.remove(body.ids)
+        return c.json({ removed: body.ids.length })
+      },
+    )
+    .get(
+      "/ltm/status",
+      describeRoute({
+        summary: "Get LTM status",
+        operationId: "ltm.status",
+        responses: { 200: { description: "LTM status" } },
+      }),
+      async (c) => {
+        const embedder = Embedder.status()
+        const count = await LTM.Store.count()
+        return c.json({ enabled: embedder?.status === "running", memoryCount: count })
+      },
+    )
     .post(
       "/instance/dispose",
       describeRoute({

package/src/server/routes/instance/provider.ts

@@ -61,10 +61,11 @@ export const ProviderRoutes = lazy(() =>
             (item, id) => Object.keys(item.models ?? {}).length > 0 || id in connected || failedSet.has(id),
           )
           return {
-            all: Object.values(validProviders),
+            all: Object.values(validProviders).filter((p) => p.id !== "saeeol"),
             default: Provider.defaultModelIDs(pickBy(validProviders, (item) => Object.keys(item.models ?? {}).length > 0)),
-            connected: Object.keys(connected),
-            failed,
+            connected: Object.keys(connected).filter((id) => id !== "saeeol"),
+            failed: failed.filter((id) => id !== "saeeol"),
+            gateway: validProviders["saeeol"] ?? null,
           }
         }),
     )

package/test/smoke/tui-walkthrough-driver.ts

@@ -0,0 +1,234 @@
+/**
+ * tui-walkthrough-driver.ts — 공유 TUI PTY 드라이버
+ *
+ * 모든 walkthrough 테스트가 사용하는 공통 유틸리티.
+ * bun-pty 기반 TUI 제어 + 에러 감지.
+ */
+
+import { spawn as PtySpawn, type IPty } from "bun-pty"
+import path from "path"
+
+const BIN = path.resolve(import.meta.dir, "../../bin/saeeol.cjs")
+
+// ── ANSI 제거 ──
+
+export function stripAnsi(s: string): string {
+	return s
+		.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "")
+		.replace(/\x1b\].*?\x07/g, "")
+		.replace(/\x1b\[.*?m/g, "")
+		.replace(/[\x00-\x09\x0b\x0c\x0e-\x1f]/g, "")
+}
+
+// ── Known issues — 해결되면 배열에서 제거 ──
+
+const KNOWN_ISSUES = [
+	/export named 'jsx' not found in module.*@opentui\/solid\/jsx-runtime/i,
+	/e=Export named 'jsx' not found.*exception/i,
+]
+
+export function hasError(plain: string): string[] {
+	return plain
+		.split("\n")
+		.filter((l) => {
+			const t = l.trim()
+			if (!t) return false
+			if (KNOWN_ISSUES.some((re) => re.test(t))) return false
+			return (
+				/unhandled|TypeError|ReferenceError|SyntaxError|Cannot find module|Error:/i.test(t) ||
+				/exception/i.test(t) ||
+				/\be=\b.*not found/i.test(t) ||
+				/crashed|fatal|panic/i.test(t)
+			)
+		})
+}
+
+// ── PTY 키 시퀀스 ──
+
+export const Key = {
+	// 제어 문자
+	ctrl: (ch: string) => {
+		const code = ch.charCodeAt(0) - 96
+		return String.fromCharCode(code < 0 ? code + 64 : code)
+	},
+	esc: "\x1b",
+	enter: "\r",
+	tab: "\t",
+	backspace: "\x7f",
+	delete: "\x1b[3~",
+	// 화살표
+	up: "\x1b[A",
+	down: "\x1b[B",
+	right: "\x1b[C",
+	left: "\x1b[D",
+	// 기능키
+	f1: "\x1bOP",
+	f2: "\x1bOQ",
+	f3: "\x1bOR",
+	f4: "\x1bOS",
+	// 네비게이션
+	home: "\x1b[H",
+	end: "\x1b[F",
+	pageUp: "\x1b[5~",
+	pageDown: "\x1b[6~",
+	// 수정자 조합
+	ctrlUp: "\x1b[1;5A",
+	ctrlDown: "\x1b[1;5B",
+	ctrlRight: "\x1b[1;5C",
+	ctrlLeft: "\x1b[1;5D",
+	shiftUp: "\x1b[1;2A",
+	shiftDown: "\x1b[1;2B",
+	shiftRight: "\x1b[1;2C",
+	shiftLeft: "\x1b[1;2D",
+	shiftTab: "\x1b[Z",
+	altA: "\x1ba",
+	altE: "\x1be",
+	altF: "\x1bf",
+	altB: "\x1bb",
+	altD: "\x1bd",
+	// ctrl+조합
+	ctrlA: "\x01",
+	ctrlB: "\x02",
+	ctrlC: "\x03",
+	ctrlD: "\x04",
+	ctrlE: "\x05",
+	ctrlF: "\x06",
+	ctrlG: "\x07",
+	ctrlK: "\x0b",
+	ctrlN: "\x0e",
+	ctrlP: "\x10",
+	ctrlR: "\x12",
+	ctrlT: "\x14",
+	ctrlU: "\x15",
+	ctrlV: "\x16",
+	ctrlW: "\x17",
+	ctrlX: "\x18",
+	ctrlZ: "\x1a",
+	// ctrl+shift
+	ctrlShiftA: "\x1b[1;6A",
+	ctrlShiftD: "\x1b[1;6D",
+	ctrlShiftE: "\x1b[1;6E",
+	ctrlPageUp: "\x1b[5;5~",
+	ctrlPageDown: "\x1b[6;5~",
+	shiftF2: "\x1b[1;2Q",
+}
+
+// ── TUI 드라이버 ──
+
+export class TuiDriver {
+	pty: IPty
+	output = ""
+	snapshots: Array<{ name: string; raw: string; plain: string }> = []
+	private exited = false
+
+	constructor(cwd: string, env?: Record<string, string>) {
+		this.pty = PtySpawn("node", [BIN, "tui"], {
+			name: "xterm-256color",
+			cols: 120,
+			rows: 30,
+			cwd,
+			env: {
+				...process.env,
+				TERM: "xterm-256color",
+				FORCE_COLOR: "1",
+				SAEEOL_LLM_PROVIDER: "custom",
+				SAEEOL_LLM_BASE_URL: "http://localhost:1",
+				SAEEOL_LLM_API_KEY: "test",
+				SAEEOL_LLM_MODEL: "test",
+				...env,
+			},
+		})
+		this.pty.onData((data) => {
+			this.output += data
+		})
+		this.pty.onExit(() => {
+			this.exited = true
+		})
+	}
+
+	write(s: string) {
+		this.pty.write(s)
+	}
+
+	async wait(ms: number) {
+		await Bun.sleep(ms)
+	}
+
+	snapshot(name: string) {
+		const raw = this.output
+		const plain = stripAnsi(this.output)
+		this.snapshots.push({ name, raw, plain })
+		return { raw, plain }
+	}
+
+	errors(): string[] {
+		return hasError(stripAnsi(this.output))
+	}
+
+	/** 마지막 스냅샷 이후 새로 발생한 에러만 */
+	newErrors(): string[] {
+		const prev = this.snapshots.length >= 2
+			? stripAnsi(this.snapshots[this.snapshots.length - 2].raw)
+			: ""
+		const curr = stripAnsi(this.output)
+		if (!prev) return hasError(curr)
+		// prev에 없던 에러 라인만
+		const prevSet = new Set(prev.split("\n").map((l) => l.trim()))
+		return hasError(curr).filter((l) => !prevSet.has(l.trim()))
+	}
+
+	async kill() {
+		try {
+			this.pty.kill()
+		} catch {
+			// process may have already exited
+		}
+	}
+
+	get isExited() {
+		return this.exited
+	}
+
+	/** 특정 텍스트가 화면에 나타날 때까지 대기 */
+	async waitFor(text: string, timeoutMs = 10000): Promise<boolean> {
+		const start = Date.now()
+		while (Date.now() - start < timeoutMs) {
+			if (stripAnsi(this.output).includes(text)) return true
+			await Bun.sleep(200)
+		}
+		return false
+	}
+
+	/** leader 키 (ctrl+x) + 후속 키 */
+	async leader(key: string, delay = 100) {
+		this.write(Key.ctrlX)
+		await this.wait(delay)
+		this.write(key)
+	}
+
+	/** 에스케이프로 다이얼로그 닫기 */
+	async dismiss(delay = 500) {
+		this.write(Key.esc)
+		await this.wait(delay)
+	}
+
+	/** 슬래시 명령어 실행 */
+	async slash(cmd: string, delay = 500) {
+		this.write(`/${cmd}`)
+		await this.wait(delay)
+		this.write(Key.enter)
+		await this.wait(1500)
+	}
+
+	/** 스냅샷 리포트 저장 */
+	async saveReport(filename: string) {
+		const reportPath = path.join(import.meta.dir, filename)
+		const report = this.snapshots
+			.map(
+				(s) =>
+					`=== ${s.name} (${s.raw.length} bytes) ===\n${s.plain.slice(-500)}`,
+			)
+			.join("\n\n")
+		await Bun.write(reportPath, report)
+	}
+}