@lupaflow/core 0.1.0

package/package.json

@@ -0,0 +1,31 @@
+{
+    "name":  "@lupaflow/core",
+    "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/types":  "workspace:*",
+                         "ulid":  "^2.3.0"
+                     },
+    "devDependencies":  {
+                            "tsup":  "^8.3.0",
+                            "typescript":  "^5.6.0"
+                        }
+}

package/src/errors.ts

@@ -0,0 +1,67 @@
+export class LupaError extends Error {
+  public code: string
+  public details?: Record<string, unknown>
+
+  constructor(message: string, code: string, details?: Record<string, unknown>) {
+    super(message)
+    this.name = "LupaError"
+    this.code = code
+    this.details = details
+  }
+}
+
+export class ProviderError extends LupaError {
+  public provider: string
+
+  constructor(provider: string, message: string, details?: Record<string, unknown>) {
+    super(`[${provider}] ${message}`, "PROVIDER_ERROR", details)
+    this.name = "ProviderError"
+    this.provider = provider
+  }
+}
+
+export class ToolError extends LupaError {
+  public tool: string
+
+  constructor(tool: string, message: string, details?: Record<string, unknown>) {
+    super(`[${tool}] ${message}`, "TOOL_ERROR", details)
+    this.name = "ToolError"
+    this.tool = tool
+  }
+}
+
+export class MemoryError extends LupaError {
+  constructor(message: string, details?: Record<string, unknown>) {
+    super(message, "MEMORY_ERROR", details)
+    this.name = "MemoryError"
+  }
+}
+
+export class ConfigError extends LupaError {
+  constructor(message: string, details?: Record<string, unknown>) {
+    super(message, "CONFIG_ERROR", details)
+    this.name = "ConfigError"
+  }
+}
+
+export class WorkflowError extends LupaError {
+  public stepId?: string
+
+  constructor(message: string, stepId?: string, details?: Record<string, unknown>) {
+    super(message, "WORKFLOW_ERROR", { stepId, ...details })
+    this.name = "WorkflowError"
+    this.stepId = stepId
+  }
+}
+
+export class RetryError extends LupaError {
+  public attempts: number
+  public lastError: Error
+
+  constructor(message: string, attempts: number, lastError: Error) {
+    super(message, "RETRY_ERROR", { attempts, lastError: lastError.message })
+    this.name = "RetryError"
+    this.attempts = attempts
+    this.lastError = lastError
+  }
+}

package/src/events.ts

@@ -0,0 +1,64 @@
+import { ulid } from "ulid"
+import type { LupaEvent } from "@lupaflow/types"
+
+type EventHandler = (event: LupaEvent) => void | Promise<void>
+
+export class EventBus {
+  private handlers: Map<string, Set<EventHandler>> = new Map()
+  private wildcardHandlers: Set<EventHandler> = new Set()
+  private history: LupaEvent[] = []
+  private maxHistory: number = 1000
+
+  on(name: string, handler: EventHandler): () => void {
+    if (!this.handlers.has(name)) {
+      this.handlers.set(name, new Set())
+    }
+    this.handlers.get(name)!.add(handler)
+    return () => this.handlers.get(name)?.delete(handler)
+  }
+
+  onAny(handler: EventHandler): () => void {
+    this.wildcardHandlers.add(handler)
+    return () => this.wildcardHandlers.delete(handler)
+  }
+
+  async emit(name: string, data: Partial<LupaEvent>): Promise<void> {
+    const event: LupaEvent = {
+      id: ulid(),
+      name,
+      timestamp: Date.now(),
+      ...data,
+    } as LupaEvent
+
+    this.history.push(event)
+    if (this.history.length > this.maxHistory) {
+      this.history.shift()
+    }
+
+    const handlers = this.handlers.get(name)
+    if (handlers) {
+      for (const handler of handlers) {
+        await handler(event)
+      }
+    }
+
+    for (const handler of this.wildcardHandlers) {
+      await handler(event)
+    }
+  }
+
+  getHistory(): LupaEvent[] {
+    return [...this.history]
+  }
+
+  clearHistory(): void {
+    this.history = []
+  }
+
+  removeAllListeners(): void {
+    this.handlers.clear()
+    this.wildcardHandlers.clear()
+  }
+}
+
+export const globalEventBus = new EventBus()

package/src/index.ts

@@ -0,0 +1,3 @@
+export { EventBus, globalEventBus } from "./events"
+export { LupaError, ProviderError, ToolError, MemoryError, ConfigError, WorkflowError, RetryError } from "./errors"
+export { generateId, delay, truncate, estimateTokens, deepMerge, chunkArray } from "./utils"

package/src/utils.ts

@@ -0,0 +1,47 @@
+import { ulid } from "ulid"
+
+export function generateId(): string {
+  return ulid()
+}
+
+export function delay(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms))
+}
+
+export function truncate(str: string, maxLength: number): string {
+  if (str.length <= maxLength) return str
+  return str.slice(0, maxLength - 3) + "..."
+}
+
+export function estimateTokens(text: string | null | undefined): number {
+  return Math.ceil((text || "").length / 4)
+}
+
+export function deepMerge<T extends Record<string, unknown>, S extends Record<string, unknown>>(target: T, source: S): T & S {
+  const result = { ...target } as Record<string, unknown>
+  for (const key of Object.keys(source)) {
+    const sourceVal = (source as Record<string, unknown>)[key]
+    const targetVal = result[key]
+    if (
+      sourceVal &&
+      targetVal &&
+      typeof sourceVal === "object" &&
+      !Array.isArray(sourceVal) &&
+      typeof targetVal === "object" &&
+      !Array.isArray(targetVal)
+    ) {
+      result[key] = deepMerge(targetVal as Record<string, unknown>, sourceVal as Record<string, unknown>)
+    } else if (sourceVal !== undefined) {
+      result[key] = sourceVal
+    }
+  }
+  return result as T & S
+}
+
+export function chunkArray<T>(arr: T[], size: number): T[][] {
+  const chunks: T[][] = []
+  for (let i = 0; i < arr.length; i += size) {
+    chunks.push(arr.slice(i, i + size))
+  }
+  return chunks
+}

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/],
+})