saeeol 1.0.9 → 1.1.1

package/src/ltm/pipeline.ts

@@ -0,0 +1,155 @@
+/** LTM — 백그라운드 수집 파이프라인 */
+
+import { Effect } from "effect"
+import * as Log from "@saeeol/core/util/log"
+import * as Bus from "@/bus"
+import * as Store from "@/ltm/store"
+import * as Embedder from "@/provider/local/embedder"
+import * as Episodic from "@/ltm/memory/episodic"
+import * as Semantic from "@/ltm/memory/semantic"
+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"
+
+const log = Log.create({ service: "ltm/pipeline" })
+
+let running = false
+let config: LTMConfig | undefined
+
+// ── 파이프라인 수명 ──
+
+/** 파이프라인 시작 */
+export async function start(cfg: LTMConfig, bake: LLMBakeParams): Promise<void> {
+  if (running) return
+  if (!cfg.enabled) return
+
+  config = cfg
+  running = true
+
+  log.info("pipeline starting", { model: bake.embeddingModel })
+
+  // 임베딩 서버 시작
+  const server = await Embedder.start(bake)
+  if (server.status !== "running") {
+    log.error("embedding server failed to start, pipeline disabled")
+    running = false
+    return
+  }
+
+  // 오래된 기억 정리
+  if (cfg.episodic.enabled) {
+    const pruned = await Store.prune(cfg.episodic.retainDays * 24 * 60 * 60 * 1000)
+    if (pruned > 0) {
+      log.info("pruned old episodic memories", { count: pruned })
+      void Bus.publish(LTMEvent.MemoryPruned, { count: pruned, type: "episodic" })
+    }
+  }
+
+  // 기억 수 제한
+  const count = await Store.count()
+  if (count > cfg.maxMemories) {
+    const excess = count - cfg.maxMemories
+    const memories = await Store.list()
+    const sorted = memories.sort((a, b) => a.metadata.timestamp - b.metadata.timestamp)
+    const toRemove = sorted.slice(0, excess).map((m) => m.id)
+    await Store.remove(toRemove)
+    log.info("trimmed memories to max", { removed: toRemove.length })
+  }
+
+  log.info("pipeline started", { memoryCount: await Store.count() })
+}
+
+/** 파이프라인 중지 */
+export async function stop(): Promise<void> {
+  if (!running) return
+  running = false
+  await Embedder.stop()
+  config = undefined
+  log.info("pipeline stopped")
+}
+
+/** 현재 상태 */
+export function isActive(): boolean {
+  return running
+}
+
+// ── 이벤트 핸들러 ──
+
+/** 대화 메시지 → 에피소드 기억 */
+export async function onMessageCompleted(
+  sessionID: string,
+  projectID: string | undefined,
+  userMsg: string,
+  assistantMsg: string,
+): Promise<void> {
+  if (!running || !config?.episodic.enabled) return
+
+  const memory = await Episodic.fromConversation(sessionID, projectID, userMsg, assistantMsg)
+  if (!memory) return
+
+  await Store.upsert(memory)
+  void Bus.publish(LTMEvent.MemoryStored, {
+    id: memory.id,
+    type: memory.type,
+    source: memory.metadata.source,
+  })
+}
+
+/** 파일 변경 → 시맨틱 기억 */
+export async function onFileChanged(
+  projectID: string,
+  filePath: string,
+  content: string,
+): Promise<void> {
+  if (!running || !config?.semantic.enabled || !config.semantic.indexOnFileChange) return
+
+  // 파일을 청크로 분할 (간단한 줄 기반)
+  const lines = content.split("\n")
+  const chunkSize = 50
+  const chunks: Array<{ text: string; start: number; end: number }> = []
+
+  for (let i = 0; i < lines.length; i += chunkSize) {
+    const chunk = lines.slice(i, i + chunkSize).join("\n")
+    if (chunk.trim().length > 20) {
+      chunks.push({ text: chunk, start: i + 1, end: Math.min(i + chunkSize, lines.length) })
+    }
+  }
+
+  for (const chunk of chunks) {
+    const memory = await Semantic.fromCodeChunk(
+      projectID,
+      filePath,
+      chunk.text,
+      chunk.start,
+      chunk.end,
+    )
+    if (memory) {
+      await Store.upsert(memory)
+      void Bus.publish(LTMEvent.MemoryStored, {
+        id: memory.id,
+        type: memory.type,
+        source: memory.metadata.source,
+      })
+    }
+  }
+
+  log.info("indexed file", { filePath, chunks: chunks.length })
+}
+
+/** 코드 편집 → 절차적 기억 */
+export async function onCodeEdit(
+  projectID: string | undefined,
+  filePath: string,
+  content: string,
+): Promise<void> {
+  if (!running || !config?.procedural.enabled || !config.procedural.trackPreferences) return
+
+  const signals = Procedural.extractStyleSignals(filePath, content)
+  if (signals.length === 0) return
+
+  const memories = await Procedural.fromStyleSignals(projectID, signals)
+  for (const memory of memories) {
+    await Store.upsert(memory)
+  }
+}

package/src/ltm/retrieval.ts

@@ -0,0 +1,62 @@
+/** LTM retrieval — search + prompt context injection (English, LLM-to-LLM) */
+
+import * as Log from "@saeeol/core/util/log"
+import * as Store from "@/ltm/store"
+import * as Embedder from "@/provider/local/embedder"
+import type { Memory, LTMConfig } from "@/ltm/types"
+
+const log = Log.create({ service: "ltm/retrieval" })
+
+/** Search memories relevant to a query */
+export async function search(
+  query: string,
+  config: LTMConfig,
+): Promise<Memory[]> {
+  try {
+    const vector = await Embedder.embedOne(query)
+    return Store.search(vector, {
+      topK: config.retrieval.topK,
+      minScore: config.retrieval.minScore,
+    })
+  } catch (e) {
+    log.error("retrieval search failed", { error: e })
+    return []
+  }
+}
+
+/** Format memories as prompt context block (English, consumed by LLM) */
+export function format(memories: Memory[]): string {
+  if (memories.length === 0) return ""
+
+  const lines = memories.map((m) => {
+    const date = new Date(m.metadata.timestamp).toISOString().slice(0, 10)
+    const tag = m.type
+    const summary = m.summary.slice(0, 200)
+    return `- [${date}] (${tag}) ${summary}`
+  })
+
+  return `[long-term memory — ${memories.length} recalled]\n${lines.join("\n")}`
+}
+
+/** Inject relevant memories into the session prompt */
+export async function inject(
+  query: string,
+  config: LTMConfig,
+): Promise<string | undefined> {
+  const memories = await search(query, config)
+  if (memories.length === 0) return undefined
+
+  const formatted = format(memories)
+  const tokenEstimate = Math.ceil(formatted.length / 4)
+
+  if (tokenEstimate > config.retrieval.maxTokens) {
+    const kept = Math.max(1, Math.floor(memories.length * config.retrieval.maxTokens / tokenEstimate))
+    const trimmed = memories.slice(0, kept)
+    const reduced = format(trimmed)
+    log.info("retrieval trimmed", { original: memories.length, trimmed: trimmed.length })
+    return reduced
+  }
+
+  log.info("retrieval injected", { count: memories.length, tokens: tokenEstimate })
+  return formatted
+}

package/src/ltm/scheduler.ts

@@ -0,0 +1,55 @@
+/** LTM — VRAM/작업 스케줄러 */
+
+import * as Log from "@saeeol/core/util/log"
+import type { HardwareProfile } from "./types"
+import * as GPU from "@/provider/local/gpu"
+import * as Embedder from "@/provider/local/embedder"
+import { Effect } from "effect"
+
+const log = Log.create({ service: "ltm/scheduler" })
+
+/** 현재 할당 상태 */
+export interface Allocation {
+  llm: number
+  embedding: number
+  available: number
+}
+
+/** 현재 VRAM 할당 상태 조회 */
+export async function allocation(): Promise<Allocation> {
+  const gpu = await Effect.runPromise(GPU.profile)
+  const embVRAM = Embedder.vramUsage()
+  return {
+    llm: gpu.totalVRAMMB - gpu.availableVRAMMB - embVRAM,
+    embedding: embVRAM,
+    available: gpu.availableVRAMMB,
+  }
+}
+
+/** 임베딩 백그라운드 작업 실행 가능한지 판단 */
+export async function canRunEmbedding(): Promise<boolean> {
+  const alloc = await allocation()
+  // 최소 2GB VRAM 필요
+  return alloc.available >= 2048
+}
+
+/** LLM과 임베딩 동시 실행 가능한지 판단 */
+export async function canRunConcurrent(hw: HardwareProfile): Promise<boolean> {
+  // 16GB 이상 VRAM이면 항상 동시 실행 가능
+  if (hw.totalVRAMMB >= 16384) return true
+  // 8GB 이상이면 임베딩 모델이 1GB 이하일 때 가능
+  if (hw.totalVRAMMB >= 8192 && Embedder.vramUsage() <= 1024) return true
+  // 그 외는 교대 실행
+  return false
+}
+
+/** 스케줄링 전략 반환 */
+export type Strategy = "concurrent" | "alternating" | "cpu-fallback" | "no-gpu"
+
+export async function strategy(): Promise<Strategy> {
+  const gpu = await Effect.runPromise(GPU.profile)
+  if (!gpu.cudaAvailable) return "no-gpu"
+  if (gpu.totalVRAMMB >= 16384) return "concurrent"
+  if (gpu.totalVRAMMB >= 8192) return "alternating"
+  return "cpu-fallback"
+}

package/src/ltm/store.ts

@@ -0,0 +1,150 @@
+/** LTM — 파일시스템 기반 벡터 스토어 */
+
+import path from "path"
+import { mkdir, readFile, writeFile, readdir, rm, stat } from "fs/promises"
+import * as Log from "@saeeol/core/util/log"
+import { Global } from "@saeeol/core/global"
+import type { Memory, MemoryType } from "./types"
+
+const log = Log.create({ service: "ltm/store" })
+
+// ── 코사인 유사도 ──
+
+function cosine(a: number[], b: number[]): number {
+  let dot = 0
+  let na = 0
+  let nb = 0
+  const len = Math.min(a.length, b.length)
+  for (let i = 0; i < len; i++) {
+    dot += a[i]! * b[i]!
+    na += a[i]! * a[i]!
+    nb += b[i]! * b[i]!
+  }
+  const denom = Math.sqrt(na) * Math.sqrt(nb)
+  return denom === 0 ? 0 : dot / denom
+}
+
+// ── 파일 경로 ──
+
+function storeDir(): string {
+  return path.join(Global.Path.data, "ltm", "memories")
+}
+
+function memoryPath(id: string): string {
+  return path.join(storeDir(), `${id}.json`)
+}
+
+function indexPath(): string {
+  return path.join(Global.Path.data, "ltm", "index.json")
+}
+
+async function ensure(): Promise<void> {
+  await mkdir(storeDir(), { recursive: true })
+}
+
+// ── 인덱스 ──
+
+interface Index {
+  memories: Array<{ id: string; type: MemoryType; timestamp: number; source: string }>
+}
+
+async function readIndex(): Promise<Index> {
+  try {
+    const raw = await readFile(indexPath(), "utf-8")
+    return JSON.parse(raw) as Index
+  } catch {
+    return { memories: [] }
+  }
+}
+
+async function writeIndex(idx: Index): Promise<void> {
+  await ensure()
+  await writeFile(indexPath(), JSON.stringify(idx, null, 2))
+}
+
+// ── 공개 API ──
+
+export async function upsert(memory: Memory): Promise<void> {
+  await ensure()
+  await writeFile(memoryPath(memory.id), JSON.stringify(memory, null, 2))
+
+  const idx = await readIndex()
+  const existing = idx.memories.findIndex((m) => m.id === memory.id)
+  const entry = { id: memory.id, type: memory.type, timestamp: memory.metadata.timestamp, source: memory.metadata.source }
+  if (existing >= 0) {
+    idx.memories[existing] = entry
+  } else {
+    idx.memories.push(entry)
+  }
+  await writeIndex(idx)
+  log.info("upserted", { id: memory.id, type: memory.type })
+}
+
+export async function search(
+  query: number[],
+  opts?: { topK?: number; minScore?: number; type?: MemoryType },
+): Promise<Memory[]> {
+  const topK = opts?.topK ?? 5
+  const minScore = opts?.minScore ?? 0.7
+  const idx = await readIndex()
+
+  const candidates: Memory[] = []
+  for (const entry of idx.memories) {
+    if (opts?.type && entry.type !== opts.type) continue
+    try {
+      const raw = await readFile(memoryPath(entry.id), "utf-8")
+      const mem = JSON.parse(raw) as Memory
+      const score = cosine(query, mem.vector)
+      if (score >= minScore) {
+        candidates.push({ ...mem, score })
+      }
+    } catch {
+      // 파일 삭제됨 — 인덱스에서도 제거
+    }
+  }
+
+  candidates.sort((a, b) => (b.score ?? 0) - (a.score ?? 0))
+  return candidates.slice(0, topK)
+}
+
+export async function remove(ids: string[]): Promise<void> {
+  for (const id of ids) {
+    try {
+      await rm(memoryPath(id))
+    } catch { /* already removed */ }
+  }
+
+  const idx = await readIndex()
+  const set = new Set(ids)
+  idx.memories = idx.memories.filter((m) => !set.has(m.id))
+  await writeIndex(idx)
+}
+
+export async function list(projectID?: string): Promise<Memory[]> {
+  const idx = await readIndex()
+  const result: Memory[] = []
+  for (const entry of idx.memories) {
+    try {
+      const raw = await readFile(memoryPath(entry.id), "utf-8")
+      const mem = JSON.parse(raw) as Memory
+      if (!projectID || mem.metadata.projectID === projectID) {
+        result.push(mem)
+      }
+    } catch { /* skip */ }
+  }
+  return result
+}
+
+export async function prune(olderThanMs: number): Promise<number> {
+  const cutoff = Date.now() - olderThanMs
+  const idx = await readIndex()
+  const toRemove = idx.memories.filter((m) => m.timestamp < cutoff)
+  await remove(toRemove.map((m) => m.id))
+  log.info("pruned", { count: toRemove.length })
+  return toRemove.length
+}
+
+export async function count(): Promise<number> {
+  const idx = await readIndex()
+  return idx.memories.length
+}

package/src/ltm/types.ts

@@ -0,0 +1,108 @@
+/** LTM — 장기 기억 타입 정의 */
+
+import { Schema } from "effect"
+import { optionalOmitUndefined } from "@/util/schema"
+
+// ── 기억 유형 ──
+
+export const MemoryType = Schema.Literals(["episodic", "semantic", "procedural"])
+export type MemoryType = Schema.Schema.Type<typeof MemoryType>
+
+// ── 기억 엔트리 ──
+
+export const MemoryMetadata = Schema.Struct({
+  source: Schema.String,
+  timestamp: Schema.Number,
+  projectID: optionalOmitUndefined(Schema.String),
+  sessionID: optionalOmitUndefined(Schema.String),
+  tags: Schema.mutable(Schema.Array(Schema.String)),
+})
+export type MemoryMetadata = Schema.Schema.Type<typeof MemoryMetadata>
+
+export const Memory = Schema.Struct({
+  id: Schema.String,
+  type: MemoryType,
+  content: Schema.String,
+  summary: Schema.String,
+  vector: Schema.mutable(Schema.Array(Schema.Number)),
+  metadata: MemoryMetadata,
+  score: optionalOmitUndefined(Schema.Number),
+})
+export type Memory = Schema.Schema.Type<typeof Memory>
+
+// ── 임베딩 서버 ──
+
+export const EmbedderStatus = Schema.Literals(["stopped", "starting", "running", "error"])
+export type EmbedderStatus = Schema.Schema.Type<typeof EmbedderStatus>
+
+export const EmbeddingServer = Schema.Struct({
+  id: Schema.String,
+  model: Schema.String,
+  status: EmbedderStatus,
+  endpoint: Schema.String,
+  dimensions: Schema.Number,
+  vramMB: Schema.Number,
+})
+export type EmbeddingServer = Schema.Schema.Type<typeof EmbeddingServer>
+
+// ── 하드웨어 프로파일 ──
+
+export const HardwareProfile = Schema.Struct({
+  gpuCount: Schema.Number,
+  totalVRAMMB: Schema.Number,
+  availableVRAMMB: Schema.Number,
+  totalRAMMB: Schema.Number,
+  cpuCores: Schema.Number,
+  cudaAvailable: Schema.Boolean,
+})
+export type HardwareProfile = Schema.Schema.Type<typeof HardwareProfile>
+
+// ── LLM 파라미터 (결정론적) ──
+
+export const LLMBakeParams = Schema.Struct({
+  /** 임베딩 모델 ID */
+  embeddingModel: Schema.String,
+  /** 임베딩 차원 */
+  embeddingDimensions: Schema.Number,
+  /** 임베딩 모델 VRAM 사용량 (MB) */
+  embeddingVRAMMB: Schema.Number,
+  /** 컨텍스트 길이 */
+  contextLength: Schema.Number,
+  /** 배치 사이즈 */
+  batchSize: Schema.Number,
+  /** Ollama 스레드 수 */
+  numThread: Schema.Number,
+  /** GPU 레이어 수 (-1=전체) */
+  numGPU: Schema.Number,
+  /** 생성 시 프로파일 감지 해시 (변경 시 재계산 트리거) */
+  hardwareHash: Schema.String,
+})
+export type LLMBakeParams = Schema.Schema.Type<typeof LLMBakeParams>
+
+// ── LTM 설정 ──
+
+export const LTMConfig = Schema.Struct({
+  enabled: Schema.Boolean,
+  embeddingModel: Schema.String,
+  vectorStore: Schema.Literals(["filesystem", "qdrant", "chroma"]),
+  maxMemories: Schema.Number,
+  episodic: Schema.Struct({
+    enabled: Schema.Boolean,
+    summaryInterval: Schema.Number,
+    retainDays: Schema.Number,
+  }),
+  semantic: Schema.Struct({
+    enabled: Schema.Boolean,
+    indexOnFileChange: Schema.Boolean,
+  }),
+  procedural: Schema.Struct({
+    enabled: Schema.Boolean,
+    trackPreferences: Schema.Boolean,
+  }),
+  retrieval: Schema.Struct({
+    topK: Schema.Number,
+    minScore: Schema.Number,
+    maxTokens: Schema.Number,
+  }),
+})
+export type LTMConfig = Schema.Schema.Type<typeof LTMConfig>

package/src/mcp/index.ts

@@ -46,6 +46,7 @@ export interface Interface {
   readonly add: (name: string, mcp: ConfigMCP.Info) => Effect.Effect<{ status: Record<string, Status> | Status }>
   readonly connect: (name: string) => Effect.Effect<void>
   readonly disconnect: (name: string) => Effect.Effect<void>
+  readonly refresh: () => Effect.Effect<Record<string, Status>>
   readonly getPrompt: (clientName: string, name: string, args?: Record<string, string>) => Effect.Effect<Awaited<ReturnType<MCPClient["getPrompt"]>> | undefined>
   readonly readResource: (clientName: string, resourceUri: string) => Effect.Effect<Awaited<ReturnType<MCPClient["readResource"]>> | undefined>
   readonly startAuth: (mcpName: string) => Effect.Effect<{ authorizationUrl: string; oauthState: string }>
@@ -251,6 +252,35 @@ export const layer = Layer.effect(
       yield* closeClient(s, name); delete s.clients[name]; s.status[name] = { status: "disabled" }
     })
 
+    const refresh = Effect.fn("MCP.refresh")(function* () {
+      const s = yield* InstanceState.get(state)
+      const cfg = yield* cfgSvc.get()
+      const config = cfg.mcp ?? {}
+      // Disconnect servers no longer in config
+      for (const name of Object.keys(s.clients)) {
+        if (!config[name] || !isMcpConfigured(config[name])) {
+          log.info("removing server no longer in config", { name })
+          yield* closeClient(s, name); delete s.clients[name]; delete s.defs[name]; delete s.status[name]
+        }
+      }
+      // Connect new or reconnect changed servers
+      yield* Effect.forEach(Object.entries(config), ([key, mcp]) =>
+        Effect.gen(function* () {
+          if (!isMcpConfigured(mcp)) return
+          if (mcp.enabled === false) {
+            if (s.clients[key]) { yield* closeClient(s, key); delete s.clients[key]; delete s.defs[key] }
+            s.status[key] = { status: "disabled" }
+            return
+          }
+          const result = yield* create(key, mcp).pipe(Effect.catch(() => Effect.void))
+          if (!result) return
+          s.status[key] = result.status
+          if (result.mcpClient) yield* storeClient(s, key, result.mcpClient, result.defs!, mcp.timeout)
+        }), { concurrency: "unbounded" })
+      yield* bus.publish(ToolsChanged, { server: "*" }).pipe(Effect.ignore)
+      return s.status
+    })
+
     const tools = Effect.fn("MCP.tools")(function* () {
       const result: Record<string, Tool> = {}
       const s = yield* InstanceState.get(state)
@@ -395,7 +425,7 @@ export const layer = Layer.effect(
       return (expired ? "expired" : "authenticated") as AuthStatus
     })
 
-    return Service.of({ status, clients, tools, prompts, resources, add, connect, disconnect, getPrompt, readResource, startAuth, authenticate, finishAuth, removeAuth, supportsOAuth, hasStoredTokens, getAuthStatus })
+    return Service.of({ status, clients, tools, prompts, resources, add, connect, disconnect, refresh, getPrompt, readResource, startAuth, authenticate, finishAuth, removeAuth, supportsOAuth, hasStoredTokens, getAuthStatus })
   }),
 )
 
@@ -410,4 +440,5 @@ const { runPromise } = makeRuntime(Service, defaultLayer)
 export const status = () => runPromise((svc) => svc.status())
 export const connect = (name: string) => runPromise((svc) => svc.connect(name))
 export const disconnect = (name: string) => runPromise((svc) => svc.disconnect(name))
+export const refresh = () => runPromise((svc) => svc.refresh())
 export * as MCP from "."

package/src/provider/custom-loaders.ts

@@ -4,10 +4,12 @@ import type { Info } from "./provider-schema"
 import { useLanguageModel } from "./bundled-providers"
 import { cloudLoaders } from "./loader-cloud"
 import { platformLoaders } from "./loader-platform"
+import { localLoaders } from "./loader-local"
 import { iife } from "@/util/iife"
 
 export function custom(dep: CustomDep): Record<string, CustomLoader> {
   return {
+    ...localLoaders(dep),
     ...cloudLoaders(dep),
     ...platformLoaders(dep),
     anthropic: () =>
@@ -161,3 +163,13 @@ export function custom(dep: CustomDep): Record<string, CustomLoader> {
       }),
   }
 }
+
+// Provider ID lists by category
+export const LOCAL_PROVIDERS = ["ollama", "lmstudio", "vllm", "text-generation-webui", "llama.cpp"] as const
+export const CUSTOM_PROVIDERS = ["llmgateway", "openrouter", "nvidia", "vercel", "zenmux", "cerebras"] as const
+export const CLOUD_PROVIDERS = [
+  "anthropic", "openai", "xai", "saeeol",
+  "azure", "azure-cognitive-services", "amazon-bedrock",
+  "google-vertex", "google-vertex-anthropic", "sap-ai-core",
+  "gitlab", "cloudflare-workers-ai", "cloudflare-ai-gateway", "github-copilot",
+] as const