@lupaflow/memory 0.1.0

package/package.json

@@ -0,0 +1,31 @@
+{
+    "name":  "@lupaflow/memory",
+    "version":  "0.1.0",
+    "type":  "module",
+    "license":  "MIT",
+    "publishConfig":  {
+                          "access":  "public"
+                      },
+    "main":  "./dist/index.js",
+    "module":  "./dist/index.js",
+    "types":  "./dist/index.d.ts",
+    "exports":  {
+                    ".":  {
+                              "types":  "./dist/index.d.ts",
+                              "require":  "./dist/index.js",
+                              "import":  "./dist/index.js"
+                          }
+                },
+    "scripts":  {
+                    "build":  "tsup",
+                    "dev":  "tsup --watch"
+                },
+    "dependencies":  {
+                         "@lupaflow/core":  "workspace:*",
+                         "@lupaflow/types":  "workspace:*"
+                     },
+    "devDependencies":  {
+                            "tsup":  "^8.3.0",
+                            "typescript":  "^5.6.0"
+                        }
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+export { MemoryStore } from "./store"
+export { ShortTermMemory } from "./short-term"
+export { LongTermMemory } from "./long-term"
+export { SemanticMemory } from "./semantic"
+export { SessionMemory } from "./session"
+export { UserMemory } from "./user"
+export { ProjectMemory } from "./project"
+export { VectorMemory } from "./vector"
+export type { MemoryBackend } from "./interface"

package/src/interface.ts

@@ -0,0 +1,11 @@
+import type { MemoryEntry, MemoryQuery, MemorySearchResult, MemoryType } from "@lupaflow/types"
+
+export interface MemoryBackend {
+  readonly type: MemoryType
+
+  store(entry: MemoryEntry): Promise<void>
+  retrieve(query: MemoryQuery): Promise<MemoryEntry[]>
+  search(query: string, limit?: number): Promise<MemorySearchResult[]>
+  delete(key: string): Promise<void>
+  clear(): Promise<void>
+}

package/src/long-term.ts

@@ -0,0 +1,70 @@
+import { readFile, writeFile, access } from "fs/promises"
+import { join } from "path"
+import type { MemoryEntry, MemoryQuery, MemorySearchResult } from "@lupaflow/types"
+import type { MemoryBackend } from "./interface"
+import { generateId } from "@lupaflow/core"
+
+export class LongTermMemory implements MemoryBackend {
+  readonly type = "long-term" as const
+  private entries: MemoryEntry[] = []
+  private filePath: string
+
+  constructor(name = "default") {
+    this.filePath = join(process.cwd(), ".lupaflow", `memory-${name}.json`)
+  }
+
+  async init(): Promise<void> {
+    try {
+      await access(this.filePath)
+      const data = await readFile(this.filePath, "utf-8")
+      this.entries = JSON.parse(data)
+    } catch {
+      this.entries = []
+    }
+  }
+
+  async persist(): Promise<void> {
+    const dir = join(process.cwd(), ".lupaflow")
+    try {
+      await access(dir)
+    } catch {
+      await writeFile(dir, "", { flag: "a" })
+    }
+    await writeFile(this.filePath, JSON.stringify(this.entries, null, 2))
+  }
+
+  async store(entry: MemoryEntry): Promise<void> {
+    this.entries.push({
+      ...entry,
+      id: entry.id || generateId(),
+      timestamp: entry.timestamp || Date.now(),
+    })
+    await this.persist()
+  }
+
+  async retrieve(query: MemoryQuery): Promise<MemoryEntry[]> {
+    let results = this.entries
+    if (query.key) results = results.filter((e) => e.key === query.key)
+    if (query.type) results = results.filter((e) => e.type === query.type)
+    if (query.scope) results = results.filter((e) => e.scope === query.scope)
+    return results.slice(-(query.limit || 50))
+  }
+
+  async search(_query: string, limit = 10): Promise<MemorySearchResult[]> {
+    const q = _query.toLowerCase()
+    return this.entries
+      .filter((e) => e.content.toLowerCase().includes(q))
+      .slice(-limit)
+      .map((entry) => ({ entry, score: 1 }))
+  }
+
+  async delete(key: string): Promise<void> {
+    this.entries = this.entries.filter((e) => e.key !== key)
+    await this.persist()
+  }
+
+  async clear(): Promise<void> {
+    this.entries = []
+    await this.persist()
+  }
+}

package/src/project.ts

@@ -0,0 +1,67 @@
+import type { MemoryEntry, MemoryQuery, MemorySearchResult } from "@lupaflow/types"
+import type { MemoryBackend } from "./interface"
+import { generateId } from "@lupaflow/core"
+import { readFile, writeFile, access } from "fs/promises"
+
+const PROJECT_MEMORY_FILE = ".lupaflow/project-memory.json"
+
+export class ProjectMemory implements MemoryBackend {
+  readonly type = "project" as const
+  private entries: MemoryEntry[] = []
+  private loaded = false
+
+  async ensureLoaded(): Promise<void> {
+    if (this.loaded) return
+    try {
+      await access(PROJECT_MEMORY_FILE)
+      const data = await readFile(PROJECT_MEMORY_FILE, "utf-8")
+      this.entries = JSON.parse(data)
+    } catch {
+      this.entries = []
+    }
+    this.loaded = true
+  }
+
+  async persist(): Promise<void> {
+    await writeFile(PROJECT_MEMORY_FILE, JSON.stringify(this.entries, null, 2))
+  }
+
+  async store(entry: MemoryEntry): Promise<void> {
+    await this.ensureLoaded()
+    this.entries.push({
+      ...entry,
+      id: entry.id || generateId(),
+      scope: "project",
+      timestamp: entry.timestamp || Date.now(),
+    })
+    await this.persist()
+  }
+
+  async retrieve(query: MemoryQuery): Promise<MemoryEntry[]> {
+    await this.ensureLoaded()
+    let results = this.entries.filter((e) => e.scope === "project")
+    if (query.key) results = results.filter((e) => e.key === query.key)
+    return results.slice(-(query.limit || 50))
+  }
+
+  async search(_query: string, limit = 10): Promise<MemorySearchResult[]> {
+    await this.ensureLoaded()
+    const q = _query.toLowerCase()
+    return this.entries
+      .filter((e) => e.scope === "project" && e.content.toLowerCase().includes(q))
+      .slice(-limit)
+      .map((entry) => ({ entry, score: 1 }))
+  }
+
+  async delete(key: string): Promise<void> {
+    await this.ensureLoaded()
+    this.entries = this.entries.filter((e) => !(e.key === key && e.scope === "project"))
+    await this.persist()
+  }
+
+  async clear(): Promise<void> {
+    await this.ensureLoaded()
+    this.entries = this.entries.filter((e) => e.scope !== "project")
+    await this.persist()
+  }
+}

package/src/semantic.ts

@@ -0,0 +1,70 @@
+import type { MemoryEntry, MemoryQuery, MemorySearchResult } from "@lupaflow/types"
+import type { MemoryBackend } from "./interface"
+import { generateId } from "@lupaflow/core"
+
+function cosineSimilarity(a: number[], b: number[]): number {
+  let dot = 0, magA = 0, magB = 0
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i]
+    magA += a[i] * a[i]
+    magB += b[i] * b[i]
+  }
+  const denom = Math.sqrt(magA) * Math.sqrt(magB)
+  return denom === 0 ? 0 : dot / denom
+}
+
+function simpleEmbed(text: string): number[] {
+  const dim = 128
+  const vec = new Array(dim).fill(0)
+  for (let i = 0; i < text.length; i++) {
+    const idx = (text.charCodeAt(i) * 7 + i * 13) % dim
+    vec[idx] += 1 + (text.charCodeAt(i) % 5) * 0.1
+  }
+  const mag = Math.sqrt(vec.reduce((s, v) => s + v * v, 0))
+  return mag > 0 ? vec.map((v) => v / mag) : vec
+}
+
+interface SemanticEntry extends MemoryEntry {
+  embedding: number[]
+}
+
+export class SemanticMemory implements MemoryBackend {
+  readonly type = "semantic" as const
+  private entries: SemanticEntry[] = []
+
+  async store(entry: MemoryEntry): Promise<void> {
+    this.entries.push({
+      ...entry,
+      id: entry.id || generateId(),
+      timestamp: entry.timestamp || Date.now(),
+      embedding: simpleEmbed(entry.content),
+    })
+  }
+
+  async retrieve(query: MemoryQuery): Promise<MemoryEntry[]> {
+    let results = this.entries
+    if (query.key) results = results.filter((e) => e.key === query.key)
+    if (query.scope) results = results.filter((e) => e.scope === query.scope)
+    return results.slice(-(query.limit || 20))
+  }
+
+  async search(_query: string, limit = 10): Promise<MemorySearchResult[]> {
+    const queryEmbedding = simpleEmbed(_query)
+    const scored = this.entries
+      .map((entry) => ({
+        entry,
+        score: cosineSimilarity(queryEmbedding, entry.embedding),
+      }))
+      .sort((a, b) => b.score - a.score)
+      .slice(0, limit)
+    return scored
+  }
+
+  async delete(key: string): Promise<void> {
+    this.entries = this.entries.filter((e) => e.key !== key)
+  }
+
+  async clear(): Promise<void> {
+    this.entries = []
+  }
+}

package/src/session.ts

@@ -0,0 +1,41 @@
+import type { MemoryEntry, MemoryQuery, MemorySearchResult } from "@lupaflow/types"
+import type { MemoryBackend } from "./interface"
+import { generateId } from "@lupaflow/core"
+
+const SESSION_KEY = "__session__"
+
+export class SessionMemory implements MemoryBackend {
+  readonly type = "session" as const
+  private entries: MemoryEntry[] = []
+
+  async store(entry: MemoryEntry): Promise<void> {
+    this.entries.push({
+      ...entry,
+      id: entry.id || generateId(),
+      scope: SESSION_KEY,
+      timestamp: entry.timestamp || Date.now(),
+    })
+  }
+
+  async retrieve(query: MemoryQuery): Promise<MemoryEntry[]> {
+    let results = this.entries.filter((e) => e.scope === SESSION_KEY)
+    if (query.key) results = results.filter((e) => e.key === query.key)
+    return results.slice(-(query.limit || 50))
+  }
+
+  async search(_query: string, limit = 10): Promise<MemorySearchResult[]> {
+    const q = _query.toLowerCase()
+    return this.entries
+      .filter((e) => e.scope === SESSION_KEY && e.content.toLowerCase().includes(q))
+      .slice(-limit)
+      .map((entry) => ({ entry, score: 1 }))
+  }
+
+  async delete(key: string): Promise<void> {
+    this.entries = this.entries.filter((e) => e.key !== key && e.scope === SESSION_KEY)
+  }
+
+  async clear(): Promise<void> {
+    this.entries = this.entries.filter((e) => e.scope !== SESSION_KEY)
+  }
+}

package/src/short-term.ts

@@ -0,0 +1,54 @@
+import type { MemoryEntry, MemoryQuery, MemorySearchResult } from "@lupaflow/types"
+import type { MemoryBackend } from "./interface"
+import { generateId } from "@lupaflow/core"
+
+export class ShortTermMemory implements MemoryBackend {
+  readonly type = "short-term" as const
+  private entries: MemoryEntry[] = []
+  private maxEntries: number
+
+  constructor(maxEntries = 50) {
+    this.maxEntries = maxEntries
+  }
+
+  async store(entry: MemoryEntry): Promise<void> {
+    this.entries.push({
+      ...entry,
+      id: entry.id || generateId(),
+      timestamp: entry.timestamp || Date.now(),
+    })
+    if (this.entries.length > this.maxEntries) {
+      this.entries.shift()
+    }
+  }
+
+  async retrieve(query: MemoryQuery): Promise<MemoryEntry[]> {
+    let results = this.entries
+    if (query.key) {
+      results = results.filter((e) => e.key === query.key)
+    }
+    if (query.scope) {
+      results = results.filter((e) => e.scope === query.scope)
+    }
+    return results.slice(-(query.limit || 20))
+  }
+
+  async search(_query: string, limit = 5): Promise<MemorySearchResult[]> {
+    const q = _query.toLowerCase()
+    const results = this.entries
+      .filter((e) => e.content.toLowerCase().includes(q))
+      .slice(-limit)
+    return results.map((entry) => ({
+      entry,
+      score: 1,
+    }))
+  }
+
+  async delete(key: string): Promise<void> {
+    this.entries = this.entries.filter((e) => e.key !== key)
+  }
+
+  async clear(): Promise<void> {
+    this.entries = []
+  }
+}

package/src/store.ts

@@ -0,0 +1,91 @@
+import type { MemoryBackend } from "./interface"
+import type { MemoryEntry, MemoryQuery, MemorySearchResult, MemoryType } from "@lupaflow/types"
+import { ShortTermMemory } from "./short-term"
+import { LongTermMemory } from "./long-term"
+import { SemanticMemory } from "./semantic"
+import { SessionMemory } from "./session"
+import { UserMemory } from "./user"
+import { ProjectMemory } from "./project"
+import { MemoryError } from "@lupaflow/core"
+import { globalEventBus } from "@lupaflow/core"
+
+export class MemoryStore {
+  private backends: Map<MemoryType, MemoryBackend> = new Map()
+
+  constructor(config?: { shortTerm?: boolean; longTerm?: boolean; semantic?: boolean; session?: boolean; user?: string; project?: boolean }) {
+    if (config?.shortTerm !== false) this.backends.set("short-term", new ShortTermMemory())
+    if (config?.longTerm) this.backends.set("long-term", new LongTermMemory())
+    if (config?.semantic) this.backends.set("semantic", new SemanticMemory())
+    if (config?.session !== false) this.backends.set("session", new SessionMemory())
+    if (config?.user) this.backends.set("user", new UserMemory(config.user))
+    if (config?.project) this.backends.set("project", new ProjectMemory())
+  }
+
+  register(type: MemoryType, backend: MemoryBackend): void {
+    this.backends.set(type, backend)
+  }
+
+  get(type: MemoryType): MemoryBackend {
+    const backend = this.backends.get(type)
+    if (!backend) throw new MemoryError(`No memory backend registered: ${type}`)
+    return backend
+  }
+
+  async store(entry: MemoryEntry): Promise<void> {
+    if (entry.type === "short-term" || entry.type === "session") {
+      const backend = this.backends.get(entry.type)
+      if (backend) {
+        await backend.store(entry)
+        await globalEventBus.emit("memory:update", {
+          type: entry.type,
+          key: entry.key,
+        } as any)
+      }
+      return
+    }
+
+    for (const backend of this.backends.values()) {
+      await backend.store({ ...entry })
+    }
+    await globalEventBus.emit("memory:update", { type: entry.type, key: entry.key } as any)
+  }
+
+  async retrieve(query: MemoryQuery): Promise<MemoryEntry[]> {
+    if (query.type) {
+      const backend = this.get(query.type)
+      const results = await backend.retrieve(query)
+      await globalEventBus.emit("memory:retrieve", {
+        type: query.type,
+        key: query.key || "all",
+        results: results.length,
+      } as any)
+      return results
+    }
+
+    const all: MemoryEntry[] = []
+    for (const backend of this.backends.values()) {
+      all.push(...(await backend.retrieve(query)))
+    }
+    return all
+  }
+
+  async search(query: string, limit = 10): Promise<MemorySearchResult[]> {
+    const all: MemorySearchResult[] = []
+    for (const backend of this.backends.values()) {
+      all.push(...(await backend.search(query, limit)))
+    }
+    return all.sort((a, b) => b.score - a.score).slice(0, limit)
+  }
+
+  async delete(key: string): Promise<void> {
+    for (const backend of this.backends.values()) {
+      await backend.delete(key)
+    }
+  }
+
+  async clear(): Promise<void> {
+    for (const backend of this.backends.values()) {
+      await backend.clear()
+    }
+  }
+}

package/src/user.ts

@@ -0,0 +1,46 @@
+import type { MemoryEntry, MemoryQuery, MemorySearchResult } from "@lupaflow/types"
+import type { MemoryBackend } from "./interface"
+import { generateId } from "@lupaflow/core"
+
+export class UserMemory implements MemoryBackend {
+  readonly type = "user" as const
+  private entries: MemoryEntry[] = []
+  private userId: string
+
+  constructor(userId: string) {
+    this.userId = userId
+  }
+
+  async store(entry: MemoryEntry): Promise<void> {
+    this.entries.push({
+      ...entry,
+      id: entry.id || generateId(),
+      scope: `user:${this.userId}`,
+      timestamp: entry.timestamp || Date.now(),
+    })
+  }
+
+  async retrieve(query: MemoryQuery): Promise<MemoryEntry[]> {
+    let results = this.entries.filter((e) => e.scope === `user:${this.userId}`)
+    if (query.key) results = results.filter((e) => e.key === query.key)
+    return results.slice(-(query.limit || 50))
+  }
+
+  async search(_query: string, limit = 10): Promise<MemorySearchResult[]> {
+    const q = _query.toLowerCase()
+    return this.entries
+      .filter((e) => e.scope === `user:${this.userId}` && e.content.toLowerCase().includes(q))
+      .slice(-limit)
+      .map((entry) => ({ entry, score: 1 }))
+  }
+
+  async delete(key: string): Promise<void> {
+    this.entries = this.entries.filter(
+      (e) => !(e.key === key && e.scope === `user:${this.userId}`)
+    )
+  }
+
+  async clear(): Promise<void> {
+    this.entries = this.entries.filter((e) => e.scope !== `user:${this.userId}`)
+  }
+}

package/src/vector.ts

@@ -0,0 +1,73 @@
+import type { MemoryEntry, MemoryQuery, MemorySearchResult } from "@lupaflow/types"
+import type { MemoryBackend } from "./interface"
+import { generateId } from "@lupaflow/core"
+
+function cosineSimilarity(a: number[], b: number[]): number {
+  let dot = 0, magA = 0, magB = 0
+  for (let i = 0; i < a.length; i++) {
+    dot += a[i] * b[i]
+    magA += a[i] * a[i]
+    magB += b[i] * b[i]
+  }
+  const denom = Math.sqrt(magA) * Math.sqrt(magB)
+  return denom === 0 ? 0 : dot / denom
+}
+
+function generateEmbedding(text: string): number[] {
+  const dim = 384
+  const vec = new Array(dim).fill(0)
+  for (let i = 0; i < text.length; i++) {
+    const code = text.charCodeAt(i)
+    for (let j = 0; j < 5; j++) {
+      const idx = (code * (j + 1) + i * 17 + j * 31) % dim
+      vec[idx] += 1.0 / (j + 1)
+    }
+  }
+  const mag = Math.sqrt(vec.reduce((s, v) => s + v * v, 0))
+  return mag > 0 ? vec.map((v) => v / mag) : vec
+}
+
+interface VectorEntry extends MemoryEntry {
+  embedding: number[]
+}
+
+export class VectorMemory implements MemoryBackend {
+  readonly type = "vector" as const
+  private entries: VectorEntry[] = []
+
+  async store(entry: MemoryEntry): Promise<void> {
+    this.entries.push({
+      ...entry,
+      id: entry.id || generateId(),
+      timestamp: entry.timestamp || Date.now(),
+      embedding: generateEmbedding(entry.content),
+    })
+  }
+
+  async retrieve(query: MemoryQuery): Promise<MemoryEntry[]> {
+    let results: MemoryEntry[] = this.entries
+    if (query.key) results = results.filter((e) => e.key === query.key)
+    if (query.scope) results = results.filter((e) => e.scope === query.scope)
+    return results.slice(-(query.limit || 20))
+  }
+
+  async search(_query: string, limit = 10, threshold = 0.3): Promise<MemorySearchResult[]> {
+    const queryEmbedding = generateEmbedding(_query)
+    return this.entries
+      .map((entry) => ({
+        entry,
+        score: cosineSimilarity(queryEmbedding, entry.embedding),
+      }))
+      .filter((r) => r.score >= threshold)
+      .sort((a, b) => b.score - a.score)
+      .slice(0, limit)
+  }
+
+  async delete(key: string): Promise<void> {
+    this.entries = this.entries.filter((e) => e.key !== key)
+  }
+
+  async clear(): Promise<void> {
+    this.entries = []
+  }
+}

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "rootDir": "./src"
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,9 @@
+import { defineConfig } from "tsup"
+export default defineConfig({
+  entry: { index: "src/index.ts" },
+  format: ["cjs", "esm"],
+  dts: true,
+  sourcemap: true,
+  clean: true,
+  external: [/node_modules/],
+})