saeeol 1.2.5 → 1.2.8

package/test/lsp/lifecycle.test.ts

@@ -1,184 +0,0 @@
-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

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

@@ -1,178 +0,0 @@
-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()
-      }
-    },
-  })
-})