saeeol 1.4.2 → 1.4.4

package/src/ltm/pipeline.ts

@@ -1,241 +0,0 @@
-/** LTM — background collection pipeline */
-
-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"
-import { Event as SessionEvent } from "@/session/core/session-types"
-
-const log = Log.create({ service: "ltm/pipeline" })
-
-let running = false
-let config: LTMConfig | undefined
-let unsubscribers: Array<() => void> = []
-
-/** Start the pipeline */
-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 })
-  }
-  bindSubscriptions()
-
-  log.info("pipeline started", { memoryCount: await Store.count() })
-}
-
-/** Stop the pipeline */
-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")
-}
-
-/** Current state */
-export function isActive(): boolean {
-  return running
-}
-
-function bindSubscriptions() {
-  if (!config) return
-
-  // 1. Session diff → episodic memory (after code change + AI response)
-  const unsubDiff = Bus.subscribe(SessionEvent.Diff, async (event) => {
-    if (!running || !config?.episodic.enabled) return
-
-    const sessionID = event.properties.sessionID
-    // diff events fire when session state is updated after an assistant response
-    // Contains both user message and assistant response context
-    const diffs = event.properties.diff
-    if (!diffs || diffs.length === 0) return
-
-    const summary = `code changes: ${diffs.map((d) => `${d.file} (${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. Session error → episodic memory (problem/resolution tracking)
-  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 })
-}
-
-/** Conversation message → episodic memory */
-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,
-  })
-}
-
-/** File change → semantic memory */
-export async function onFileChanged(
-  projectID: string,
-  filePath: string,
-  content: string,
-): Promise<void> {
-  if (!running || !config?.semantic.enabled || !config.semantic.indexOnFileChange) return
-
-  // Check VRAM scheduler — can we run embedding?
-  const canRun = await Scheduler.canRunEmbedding()
-  if (!canRun) {
-    log.info("skipping file indexing — VRAM budget exceeded", { filePath })
-    return
-  }
-
-  // Split file into chunks (simple line-based)
-  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 })
-}
-
-/** Code edit → procedural memory */
-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

@@ -1,62 +0,0 @@
-/** 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

@@ -1,117 +0,0 @@
-/** LTM — VRAM/task scheduler */
-
-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" })
-
-/** Current allocation state */
-export interface Allocation {
-  llm: number
-  embedding: number
-  available: number
-}
-
-/** Scheduling strategy */
-export type Strategy = "concurrent" | "alternating" | "cpu-fallback" | "no-gpu"
-
-/** Query current VRAM allocation state */
-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,
-  }
-}
-
-/** Return the scheduling strategy */
-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"
-}
-
-/** Whether embedding background work can run */
-export async function canRunEmbedding(): Promise<boolean> {
-  const strat = await strategy()
-  // no-gpu or cpu-fallback: always allowed (CPU processing)
-  if (strat === "no-gpu" || strat === "cpu-fallback") return true
-  if (strat === "concurrent") return true
-  // alternating: need at least 2GB VRAM
-  const alloc = await allocation()
-  return alloc.available >= 2048
-}
-
-/** Whether LLM and embedding can run concurrently */
-export async function canRunConcurrent(hw: HardwareProfile): Promise<boolean> {
-  if (hw.totalVRAMMB >= 16384) return true
-  if (hw.totalVRAMMB >= 8192 && Embedder.vramUsage() <= 1024) return true
-  return false
-}
-
-/** Called when LLM requests VRAM — pauses embedding if needed */
-export async function requestLLM(vramNeededMB: number): Promise<boolean> {
-  const strat = await strategy()
-  if (strat === "concurrent") return true
-  if (strat === "no-gpu") return true
-
-  const alloc = await allocation()
-  if (alloc.available >= vramNeededMB) {
-    log.info("LLM request: enough VRAM", { available: alloc.available, needed: vramNeededMB })
-    return true
-  }
-
-  // alternating strategy: pause embedding to free VRAM
-  if (strat === "alternating" && alloc.embedding > 0) {
-    log.info("LLM request: pausing embedding to free VRAM", {
-      embedding: alloc.embedding,
-      needed: vramNeededMB,
-    })
-    await Embedder.stop()
-    return true
-  }
-
-  // cpu-fallback: embedding already runs on CPU, GPU is LLM-exclusive
-  if (strat === "cpu-fallback") return true
-
-  log.warn("LLM request: insufficient VRAM", { available: alloc.available, needed: vramNeededMB })
-  return false
-}
-
-/** Resume embedding server — called when LLM goes idle */
-export async function resumeEmbedding(bake: {
-  embeddingModel: string
-  embeddingDimensions: number
-}): Promise<void> {
-  const current = Embedder.status()
-  if (current?.status === "running") return
-
-  const canRun = await canRunEmbedding()
-  if (!canRun) {
-    log.info("embedder resume skipped — VRAM budget exceeded")
-    return
-  }
-
-  log.info("resuming embedding server after LLM idle")
-  try {
-    await Embedder.start({
-      embeddingModel: bake.embeddingModel,
-      embeddingDimensions: bake.embeddingDimensions,
-      embeddingVRAMMB: 0,
-      contextLength: 4096,
-      batchSize: 16,
-      numThread: 4,
-      numGPU: 0,
-      hardwareHash: "",
-    })
-  } catch (e) {
-    log.error("failed to resume embedding server", { error: e })
-  }
-}

package/src/ltm/store.ts

@@ -1,143 +0,0 @@
-/** LTM — filesystem-based vector store */
-
-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 {
-  const safe = id.replace(/[:<>\"|?*]/g, "_")
-  return path.join(storeDir(), `${safe}.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))
-}
-
-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 {
-      // File deleted — remove from index too
-    }
-  }
-
-  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

@@ -1,102 +0,0 @@
-/** LTM — long-term memory type definitions */
-
-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>
-
-
-export const LLMBakeParams = Schema.Struct({
-  /** Embedding model ID */
-  embeddingModel: Schema.String,
-  /** Embedding dimensions */
-  embeddingDimensions: Schema.Number,
-  /** Embedding model VRAM usage (MB) */
-  embeddingVRAMMB: Schema.Number,
-  /** Context length */
-  contextLength: Schema.Number,
-  /** Batch size */
-  batchSize: Schema.Number,
-  /** Ollama thread count */
-  numThread: Schema.Number,
-  /** GPU layer count (-1=all) */
-  numGPU: Schema.Number,
-  /** Profile detection hash at generation time (triggers recompute on change) */
-  hardwareHash: Schema.String,
-})
-export type LLMBakeParams = Schema.Schema.Type<typeof LLMBakeParams>
-
-
-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>