saeeol 1.3.0 → 1.4.0

package/test/lsp/lifecycle.test.ts

@@ -0,0 +1,184 @@
+import { afterEach, beforeEach, describe, expect, spyOn, test } from "bun:test"
+import path from "path"
+import { Effect, Layer } from "effect"
+import { LSP } from "@/lsp/lsp"
+import * as LSPServer from "@/lsp/server"
+import { CrossSpawnSpawner } from "@saeeol/core/cross-spawn-spawner"
+import { provideTmpdirInstance } from "../fixture/fixture"
+import { testEffect } from "../lib/effect"
+
+const it = testEffect(Layer.mergeAll(LSP.defaultLayer, CrossSpawnSpawner.defaultLayer))
+
+describe("LSP service lifecycle", () => {
+  let spawnSpy: ReturnType<typeof spyOn>
+
+  beforeEach(() => {
+    spawnSpy = spyOn(LSPServer.Typescript, "spawn").mockResolvedValue(undefined)
+  })
+
+  afterEach(() => {
+    spawnSpy.mockRestore()
+  })
+
+  it.live("init() completes without error", () => provideTmpdirInstance(() => LSP.Service.use((lsp) => lsp.init())))
+
+  it.live("status() returns empty array initially", () =>
+    provideTmpdirInstance(() =>
+      LSP.Service.use((lsp) =>
+        Effect.gen(function* () {
+          const result = yield* lsp.status()
+          expect(Array.isArray(result)).toBe(true)
+          expect(result.length).toBe(0)
+        }),
+      ),
+    ),
+  )
+
+  it.live("diagnostics() returns empty object initially", () =>
+    provideTmpdirInstance(() =>
+      LSP.Service.use((lsp) =>
+        Effect.gen(function* () {
+          const result = yield* lsp.diagnostics()
+          expect(typeof result).toBe("object")
+          expect(Object.keys(result).length).toBe(0)
+        }),
+      ),
+    ),
+  )
+
+  it.live("hasClients() returns false for .ts files in instance when LSP is unset", () =>
+    provideTmpdirInstance((dir) =>
+      LSP.Service.use((lsp) =>
+        Effect.gen(function* () {
+          const result = yield* lsp.hasClients(path.join(dir, "test.ts"))
+          expect(result).toBe(false)
+        }),
+      ),
+    ),
+  )
+
+  it.live("hasClients() returns true for .ts files in instance when lsp is true", () =>
+    provideTmpdirInstance(
+      (dir) =>
+        LSP.Service.use((lsp) =>
+          Effect.gen(function* () {
+            const result = yield* lsp.hasClients(path.join(dir, "test.ts"))
+            expect(result).toBe(true)
+          }),
+        ),
+      { config: { lsp: true } },
+    ),
+  )
+
+  it.live("hasClients() keeps built-in LSPs when config object is provided", () =>
+    provideTmpdirInstance(
+      (dir) =>
+        LSP.Service.use((lsp) =>
+          Effect.gen(function* () {
+            const result = yield* lsp.hasClients(path.join(dir, "test.ts"))
+            expect(result).toBe(true)
+          }),
+        ),
+      {
+        config: {
+          lsp: {
+            eslint: { disabled: true },
+          },
+        },
+      },
+    ),
+  )
+
+  it.live("hasClients() returns false for files outside instance", () =>
+    provideTmpdirInstance((dir) =>
+      LSP.Service.use((lsp) =>
+        Effect.gen(function* () {
+          const result = yield* lsp.hasClients(path.join(dir, "..", "outside.ts"))
+          expect(typeof result).toBe("boolean")
+        }),
+      ),
+    ),
+  )
+
+  it.live("workspaceSymbol() returns empty array with no clients", () =>
+    provideTmpdirInstance(() =>
+      LSP.Service.use((lsp) =>
+        Effect.gen(function* () {
+          const result = yield* lsp.workspaceSymbol("test")
+          expect(Array.isArray(result)).toBe(true)
+          expect(result.length).toBe(0)
+        }),
+      ),
+    ),
+  )
+
+  it.live("definition() returns empty array for unknown file", () =>
+    provideTmpdirInstance((dir) =>
+      LSP.Service.use((lsp) =>
+        Effect.gen(function* () {
+          const result = yield* lsp.definition({
+            file: path.join(dir, "nonexistent.ts"),
+            line: 0,
+            character: 0,
+          })
+          expect(Array.isArray(result)).toBe(true)
+        }),
+      ),
+    ),
+  )
+
+  it.live("references() returns empty array for unknown file", () =>
+    provideTmpdirInstance((dir) =>
+      LSP.Service.use((lsp) =>
+        Effect.gen(function* () {
+          const result = yield* lsp.references({
+            file: path.join(dir, "nonexistent.ts"),
+            line: 0,
+            character: 0,
+          })
+          expect(Array.isArray(result)).toBe(true)
+        }),
+      ),
+    ),
+  )
+
+  it.live("multiple init() calls are idempotent", () =>
+    provideTmpdirInstance(() =>
+      LSP.Service.use((lsp) =>
+        Effect.gen(function* () {
+          yield* lsp.init()
+          yield* lsp.init()
+          yield* lsp.init()
+        }),
+      ),
+    ),
+  )
+})
+
+describe("LSP.Diagnostic", () => {
+  test("pretty() formats error diagnostic", () => {
+    const result = LSP.Diagnostic.pretty({
+      range: { start: { line: 9, character: 4 }, end: { line: 9, character: 10 } },
+      message: "Type 'string' is not assignable to type 'number'",
+      severity: 1,
+    } as any)
+    expect(result).toBe("ERROR [10:5] Type 'string' is not assignable to type 'number'")
+  })
+
+  test("pretty() formats warning diagnostic", () => {
+    const result = LSP.Diagnostic.pretty({
+      range: { start: { line: 0, character: 0 }, end: { line: 0, character: 5 } },
+      message: "Unused variable",
+      severity: 2,
+    } as any)
+    expect(result).toBe("WARN [1:1] Unused variable")
+  })
+
+  test("pretty() defaults to ERROR when no severity", () => {
+    const result = LSP.Diagnostic.pretty({
+      range: { start: { line: 0, character: 0 }, end: { line: 0, character: 1 } },
+      message: "Something wrong",
+    } as any)
+    expect(result).toBe("ERROR [1:1] Something wrong")
+  })
+})

package/test/ltm/ltm.test.ts

@@ -0,0 +1,230 @@
+/** LTM unit tests — store, retrieval, embedder cycle */
+
+import { describe, test, expect, beforeEach, afterEach } from "bun:test"
+import path from "path"
+import { mkdir, rm } from "fs/promises"
+import * as Store from "@/ltm/store"
+import * as Retrieval from "@/ltm/retrieval"
+import type { Memory, LTMConfig } from "@/ltm/types"
+import * as Episodic from "@/ltm/memory/episodic"
+import * as Procedural from "@/ltm/memory/procedural"
+
+// ── Mock embedder — Ollama 없이 테스트 ──
+
+const mockVectors = new Map<string, number[]>()
+
+/** 간단한 mock 임베딩 (텍스트 해시 기반) */
+function mockEmbed(text: string): number[] {
+  if (mockVectors.has(text)) return mockVectors.get(text)!
+  const vector = Array.from({ length: 384 }, (_, i) => {
+    const code = text.charCodeAt(i % text.length) || 0
+    return Math.sin(code * (i + 1)) * 0.5 + 0.5
+  })
+  mockVectors.set(text, vector)
+  return vector
+}
+
+// 테스트 설정
+const testConfig: LTMConfig = {
+  enabled: true,
+  embeddingModel: "mock",
+  vectorStore: "filesystem",
+  maxMemories: 100,
+  episodic: { enabled: true, summaryInterval: 5, retainDays: 90 },
+  semantic: { enabled: true, indexOnFileChange: true },
+  procedural: { enabled: true, trackPreferences: true },
+  retrieval: { topK: 5, minScore: 0.5, maxTokens: 2000 },
+}
+
+// ── Store 테스트 ──
+
+describe("LTM Store", () => {
+  test("upsert and search", async () => {
+    const vector = mockEmbed("hello world test")
+    const memory: Memory = {
+      id: "test:1",
+      type: "episodic",
+      content: "test content about hello world",
+      summary: "hello world test",
+      vector,
+      metadata: {
+        source: "test:unit",
+        timestamp: Date.now(),
+        tags: ["test"],
+      },
+    }
+
+    await Store.upsert(memory)
+    const results = await Store.search(vector, { topK: 5, minScore: 0.0 })
+    expect(results.length).toBeGreaterThan(0)
+    expect(results[0]!.id).toBe("test:1")
+  })
+
+  test("search filters by type", async () => {
+    const v1 = mockEmbed("episodic query")
+    await Store.upsert({
+      id: "test:epi",
+      type: "episodic",
+      content: "episodic content",
+      summary: "episodic query",
+      vector: v1,
+      metadata: { source: "test", timestamp: Date.now(), tags: [] },
+    })
+
+    const v2 = mockEmbed("semantic code query")
+    await Store.upsert({
+      id: "test:sem",
+      type: "semantic",
+      content: "code content",
+      summary: "semantic code query",
+      vector: v2,
+      metadata: { source: "test", timestamp: Date.now(), tags: [] },
+    })
+
+    const results = await Store.search(v1, { topK: 5, minScore: 0.0, type: "episodic" })
+    expect(results.every((m) => m.type === "episodic")).toBe(true)
+  })
+
+  test("remove deletes memories", async () => {
+    const id = `test-rm-${Date.now()}`
+    await Store.upsert({
+      id,
+      type: "episodic",
+      content: "to be removed",
+      summary: "remove test",
+      vector: mockEmbed("remove test"),
+      metadata: { source: "test", timestamp: Date.now(), tags: [] },
+    })
+
+    const before = await Store.count()
+    await Store.remove([id])
+    const after = await Store.count()
+    expect(after).toBeLessThanOrEqual(before)
+  })
+
+  test("prune removes old memories", async () => {
+    const oldTimestamp = Date.now() - 100 * 24 * 60 * 60 * 1000 // 100 days ago
+    const id = `test-old-${Date.now()}`
+    await Store.upsert({
+      id,
+      type: "episodic",
+      content: "old memory",
+      summary: "old memory content",
+      vector: mockEmbed("old memory content"),
+      metadata: { source: "test", timestamp: oldTimestamp, tags: [] },
+    })
+
+    const pruned = await Store.prune(90 * 24 * 60 * 60 * 1000) // 90 days
+    expect(pruned).toBeGreaterThanOrEqual(0)
+  })
+
+  test("upsert updates existing memory", async () => {
+    const id = "test:update"
+    const v1 = mockEmbed("version 1")
+    await Store.upsert({
+      id,
+      type: "semantic",
+      content: "version 1",
+      summary: "version 1",
+      vector: v1,
+      metadata: { source: "test", timestamp: 1, tags: [] },
+    })
+
+    const v2 = mockEmbed("version 2 updated")
+    await Store.upsert({
+      id,
+      type: "semantic",
+      content: "version 2",
+      summary: "version 2 updated",
+      vector: v2,
+      metadata: { source: "test", timestamp: 2, tags: [] },
+    })
+
+    const all = await Store.list()
+    const found = all.find((m) => m.id === id)
+    expect(found).toBeDefined()
+    expect(found!.content).toBe("version 2")
+  })
+
+  test("count returns total memories", async () => {
+    const count = await Store.count()
+    expect(typeof count).toBe("number")
+    expect(count).toBeGreaterThanOrEqual(0)
+  })
+})
+
+// ── Episodic Memory 테스트 ──
+
+describe("LTM Episodic Memory", () => {
+  test("shouldSummarize triggers at interval", () => {
+    expect(Episodic.shouldSummarize(10, 10)).toBe(true)
+    expect(Episodic.shouldSummarize(5, 10)).toBe(false)
+    expect(Episodic.shouldSummarize(20, 10)).toBe(true)
+    expect(Episodic.shouldSummarize(0, 10)).toBe(false)
+  })
+})
+
+// ── Procedural Memory 테스트 ──
+
+describe("LTM Procedural Memory", () => {
+  test("extractStyleSignals detects indentation", () => {
+    const signals = Procedural.extractStyleSignals("test.ts", "const x = 1\n  const y = 2\n  const z = 3")
+    const indent = signals.find((s) => s.pattern === "indent")
+    expect(indent).toBeDefined()
+    expect(indent!.evidence).toContain("2-space")
+  })
+
+  test("extractStyleSignals detects Korean comments", () => {
+    const signals = Procedural.extractStyleSignals("test.ts", "// 한국어 주석\nconst x = 1")
+    const commentLang = signals.find((s) => s.pattern === "comment-language")
+    expect(commentLang).toBeDefined()
+    expect(commentLang!.evidence).toContain("Korean")
+  })
+
+  test("extractStyleSignals detects quote style", () => {
+    const signals = Procedural.extractStyleSignals("test.ts", "const a = 'hello'\nconst b = 'world'\nconst c = 'test'")
+    const quotes = signals.find((s) => s.pattern === "quotes")
+    expect(quotes).toBeDefined()
+  })
+
+  test("extractStyleSignals returns empty for empty file", () => {
+    const signals = Procedural.extractStyleSignals("test.txt", "")
+    expect(signals).toBeArray()
+  })
+})
+
+// ── Retrieval 포맷 테스트 ──
+
+describe("LTM Retrieval", () => {
+  test("format produces context block", () => {
+    const memories: Memory[] = [
+      {
+        id: "test:r1",
+        type: "episodic",
+        content: "auth bug fix",
+        summary: "fixed CSRF vulnerability in auth/login.ts",
+        vector: [],
+        metadata: { source: "session:abc", timestamp: Date.now(), tags: ["fix", "auth"] },
+      },
+      {
+        id: "test:r2",
+        type: "semantic",
+        content: "express middleware",
+        summary: "project uses Express middleware chain pattern",
+        vector: [],
+        metadata: { source: "file:src/app.ts", timestamp: Date.now(), tags: ["architecture"] },
+      },
+    ]
+
+    const formatted = Retrieval.format(memories)
+    expect(formatted).toContain("[long-term memory")
+    expect(formatted).toContain("episodic")
+    expect(formatted).toContain("semantic")
+    expect(formatted).toContain("CSRF")
+  })
+
+  test("format returns empty for no memories", () => {
+    const formatted = Retrieval.format([])
+    expect(formatted).toBe("")
+  })
+})

package/test/mcp/headers.test.ts

@@ -0,0 +1,178 @@
+import { test, expect, mock, beforeEach } from "bun:test"
+import { Effect } from "effect"
+import type { MCP as MCPNS } from "../../src/mcp/index"
+
+// Track what options were passed to each transport constructor
+const transportCalls: Array<{
+  type: "streamable" | "sse"
+  url: string
+  options: { authProvider?: unknown; requestInit?: RequestInit }
+}> = []
+
+// Mock the transport constructors to capture their arguments
+void mock.module("@modelcontextprotocol/sdk/client/streamableHttp.js", () => ({
+  StreamableHTTPClientTransport: class MockStreamableHTTP {
+    constructor(url: URL, options?: { authProvider?: unknown; requestInit?: RequestInit }) {
+      transportCalls.push({
+        type: "streamable",
+        url: url.toString(),
+        options: options ?? {},
+      })
+    }
+    async start() {
+      throw new Error("Mock transport cannot connect")
+    }
+  },
+}))
+
+void mock.module("@modelcontextprotocol/sdk/client/sse.js", () => ({
+  SSEClientTransport: class MockSSE {
+    constructor(url: URL, options?: { authProvider?: unknown; requestInit?: RequestInit }) {
+      transportCalls.push({
+        type: "sse",
+        url: url.toString(),
+        options: options ?? {},
+      })
+    }
+    async start() {
+      throw new Error("Mock transport cannot connect")
+    }
+  },
+}))
+
+beforeEach(() => {
+  transportCalls.length = 0
+})
+
+// Import MCP after mocking
+const { MCP } = await import("../../src/mcp/index")
+const { AppRuntime } = await import("../../src/effect/app-runtime")
+const { Instance } = await import("../../src/project/instance")
+const { tmpdir } = await import("../fixture/fixture")
+const service = MCP.Service as unknown as Effect.Effect<MCPNS.Interface, never, never>
+
+test("headers are passed to transports when oauth is enabled (default)", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      await Bun.write(
+        `${dir}/saeeol.json`,
+        JSON.stringify({
+          $schema: "https://app.saeeol.ai/config.json",
+          mcp: {
+            "test-server": {
+              type: "remote",
+              url: "https://example.com/mcp",
+              headers: {
+                Authorization: "Bearer test-token",
+                "X-Custom-Header": "custom-value",
+              },
+            },
+          },
+        }),
+      )
+    },
+  })
+
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      // Trigger MCP initialization - it will fail to connect but we can check the transport options
+      await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const mcp = yield* service
+          yield* mcp
+            .add("test-server", {
+              type: "remote",
+              url: "https://example.com/mcp",
+              headers: {
+                Authorization: "Bearer test-token",
+                "X-Custom-Header": "custom-value",
+              },
+            })
+            .pipe(Effect.catch(() => Effect.void))
+        }),
+      )
+
+      // Both transports should have been created with headers
+      expect(transportCalls.length).toBeGreaterThanOrEqual(1)
+
+      for (const call of transportCalls) {
+        expect(call.options.requestInit).toBeDefined()
+        expect(call.options.requestInit?.headers).toEqual({
+          Authorization: "Bearer test-token",
+          "X-Custom-Header": "custom-value",
+        })
+        // OAuth should be enabled by default, so authProvider should exist
+        expect(call.options.authProvider).toBeDefined()
+      }
+    },
+  })
+})
+
+test("headers are passed to transports when oauth is explicitly disabled", async () => {
+  await using tmp = await tmpdir()
+
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      transportCalls.length = 0
+
+      await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const mcp = yield* service
+          yield* mcp
+            .add("test-server-no-oauth", {
+              type: "remote",
+              url: "https://example.com/mcp",
+              oauth: false,
+              headers: {
+                Authorization: "Bearer test-token",
+              },
+            })
+            .pipe(Effect.catch(() => Effect.void))
+        }),
+      )
+
+      expect(transportCalls.length).toBeGreaterThanOrEqual(1)
+
+      for (const call of transportCalls) {
+        expect(call.options.requestInit).toBeDefined()
+        expect(call.options.requestInit?.headers).toEqual({
+          Authorization: "Bearer test-token",
+        })
+        // OAuth is disabled, so no authProvider
+        expect(call.options.authProvider).toBeUndefined()
+      }
+    },
+  })
+})
+
+test("no requestInit when headers are not provided", async () => {
+  await using tmp = await tmpdir()
+
+  await Instance.provide({
+    directory: tmp.path,
+    fn: async () => {
+      transportCalls.length = 0
+
+      await AppRuntime.runPromise(
+        Effect.gen(function* () {
+          const mcp = yield* service
+          yield* mcp
+            .add("test-server-no-headers", {
+              type: "remote",
+              url: "https://example.com/mcp",
+            })
+            .pipe(Effect.catch(() => Effect.void))
+        }),
+      )
+
+      expect(transportCalls.length).toBeGreaterThanOrEqual(1)
+
+      for (const call of transportCalls) {
+        // No headers means requestInit should be undefined
+        expect(call.options.requestInit).toBeUndefined()
+      }
+    },
+  })
+})