@prysm-ai/utils 0.1.0

package/async.d.ts

@@ -0,0 +1,18 @@
+export declare function withTimeout<T>(promise: Promise<T>, timeoutMs: number, timeoutError?: Error): Promise<T>;
+export declare function retry<T>(fn: () => Promise<T>, options?: {
+    maxAttempts?: number;
+    delayMs?: number;
+    backoff?: 'linear' | 'exponential';
+    onRetry?: (attempt: number, error: Error) => void;
+}): Promise<T>;
+export declare function sleep(ms: number): Promise<void>;
+export declare function parallel<T>(tasks: (() => Promise<T>)[], maxConcurrency?: number): Promise<T[]>;
+export declare class AsyncQueue<T> {
+    private concurrency;
+    private queue;
+    private running;
+    constructor(concurrency?: number);
+    add(task: () => Promise<T>): Promise<T>;
+    private process;
+    get size(): number;
+}

package/async.js

@@ -0,0 +1,99 @@
+// Async utilities
+export async function withTimeout(promise, timeoutMs, timeoutError) {
+    let timeoutId;
+    const timeoutPromise = new Promise((_, reject) => {
+        timeoutId = setTimeout(() => {
+            reject(timeoutError ?? new Error(`Operation timed out after ${timeoutMs}ms`));
+        }, timeoutMs);
+    });
+    try {
+        return await Promise.race([promise, timeoutPromise]);
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+export async function retry(fn, options = {}) {
+    const { maxAttempts = 3, delayMs = 1000, backoff = 'linear', onRetry } = options;
+    let lastError;
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            lastError = error;
+            if (attempt < maxAttempts) {
+                const delay = backoff === 'exponential'
+                    ? delayMs * Math.pow(2, attempt - 1)
+                    : delayMs * attempt;
+                onRetry?.(attempt, lastError);
+                await sleep(delay);
+            }
+        }
+    }
+    throw lastError;
+}
+export function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+export async function parallel(tasks, maxConcurrency) {
+    if (!maxConcurrency) {
+        return Promise.all(tasks.map(fn => fn()));
+    }
+    const results = [];
+    const executing = [];
+    for (const task of tasks) {
+        const p = task().then(result => {
+            results.push(result);
+        });
+        executing.push(p);
+        if (executing.length >= maxConcurrency) {
+            await Promise.race(executing);
+            executing.splice(executing.findIndex(e => e === p), 1);
+        }
+    }
+    await Promise.all(executing);
+    return results;
+}
+export class AsyncQueue {
+    concurrency;
+    queue = [];
+    running = 0;
+    constructor(concurrency = 1) {
+        this.concurrency = concurrency;
+    }
+    async add(task) {
+        return new Promise((resolve, reject) => {
+            this.queue.push(async () => {
+                try {
+                    const result = await task();
+                    resolve(result);
+                    return result;
+                }
+                catch (error) {
+                    reject(error);
+                    throw error;
+                }
+            });
+            this.process();
+        });
+    }
+    async process() {
+        if (this.running >= this.concurrency)
+            return;
+        if (this.queue.length === 0)
+            return;
+        this.running++;
+        const task = this.queue.shift();
+        try {
+            await task();
+        }
+        finally {
+            this.running--;
+            this.process();
+        }
+    }
+    get size() {
+        return this.queue.length;
+    }
+}

package/index.d.ts

@@ -0,0 +1,3 @@
+export * from './async.js';
+export * from './validation.js';
+export * from './time.js';

package/index.js

@@ -0,0 +1,3 @@
+export * from './async.js';
+export * from './validation.js';
+export * from './time.js';

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@prysm-ai/utils",
+  "version": "0.1.0",
+  "description": "Shared utilities",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsc",
+    "build:watch": "tsc --watch",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0"
+  }
+}

package/time.d.ts

@@ -0,0 +1,21 @@
+export interface TimeContextOptions {
+    /** Timezone for display (e.g., 'UTC', 'America/New_York', 'Asia/Shanghai') */
+    timezone?: string;
+    /** Additional context to inject */
+    additionalContext?: string;
+}
+export declare function formatTimeForTimezone(date: Date, timezone: string): string;
+export declare function getCurrentTimeISO(): string;
+export declare function getCurrentTimeForTimezone(timezone: string): string;
+export interface TimeContextResult {
+    utcTime: string;
+    localTime: string;
+    timezone: string;
+    formattedContext: string;
+}
+export declare function buildTimeContext(options?: TimeContextOptions): TimeContextResult;
+export interface TimeContextMessage {
+    role: string;
+    content: string;
+}
+export declare function injectTimeContext(messages: TimeContextMessage[], options?: TimeContextOptions): TimeContextMessage[];

package/time.js

@@ -0,0 +1,70 @@
+const DEFAULT_TIME_CONTEXT = `Current UTC time: {{utcTime}}. For other timezones, use the time tool.`;
+export function formatTimeForTimezone(date, timezone) {
+    try {
+        return new Intl.DateTimeFormat('en-US', {
+            timeZone: timezone,
+            year: 'numeric',
+            month: '2-digit',
+            day: '2-digit',
+            hour: '2-digit',
+            minute: '2-digit',
+            second: '2-digit',
+            hour12: false,
+            timeZoneName: 'short',
+        }).format(date);
+    }
+    catch {
+        return date.toISOString();
+    }
+}
+export function getCurrentTimeISO() {
+    return new Date().toISOString();
+}
+export function getCurrentTimeForTimezone(timezone) {
+    return formatTimeForTimezone(new Date(), timezone);
+}
+export function buildTimeContext(options = {}) {
+    const timezone = options.timezone ?? 'UTC';
+    const now = new Date();
+    const utcTime = now.toISOString();
+    const localTime = formatTimeForTimezone(now, timezone);
+    let formattedContext = DEFAULT_TIME_CONTEXT
+        .replace('{{utcTime}}', utcTime);
+    if (options.additionalContext) {
+        formattedContext += '\n' + options.additionalContext;
+    }
+    return {
+        utcTime,
+        localTime,
+        timezone,
+        formattedContext,
+    };
+}
+export function injectTimeContext(messages, options = {}) {
+    const { formattedContext } = buildTimeContext(options);
+    if (messages.length === 0) {
+        return [{
+                role: 'system',
+                content: formattedContext,
+            }];
+    }
+    const systemMessages = messages.filter(m => m.role === 'system');
+    if (systemMessages.length > 0) {
+        const lastSystemMessage = systemMessages[systemMessages.length - 1];
+        const updatedSystemMessage = {
+            ...lastSystemMessage,
+            content: lastSystemMessage.content + '\n\n' + formattedContext,
+        };
+        const updatedMessages = messages.map(m => {
+            if (m === lastSystemMessage) {
+                return updatedSystemMessage;
+            }
+            return m;
+        });
+        return updatedMessages;
+    }
+    return [{
+            role: 'system',
+            content: formattedContext,
+        }, ...messages];
+}

package/validation.d.ts

@@ -0,0 +1,14 @@
+import type { ZodError, ZodType } from 'zod';
+export declare function deepMerge<T extends Record<string, unknown>>(target: T, ...sources: Partial<T>[]): T;
+export declare function sortObjectKeys<T extends Record<string, unknown>>(obj: T): T;
+export declare function validate<T>(schema: ZodType<T>, data: unknown): T;
+export declare function safeValidate<T>(schema: ZodType<T>, data: unknown): {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: ZodError;
+};
+export declare function requireFields(obj: Record<string, unknown>, fields: string[]): string[];
+export declare function isValidUUID(str: string): boolean;
+export declare function isValidEmail(email: string): boolean;

package/validation.js

@@ -0,0 +1,68 @@
+// Deep merge utility
+export function deepMerge(target, ...sources) {
+    const result = { ...target };
+    for (const source of sources) {
+        for (const key of Object.keys(source)) {
+            const sourceValue = source[key];
+            const targetValue = result[key];
+            if (sourceValue !== null &&
+                typeof sourceValue === 'object' &&
+                !Array.isArray(sourceValue) &&
+                targetValue !== null &&
+                typeof targetValue === 'object' &&
+                !Array.isArray(targetValue) &&
+                !(sourceValue instanceof Date) &&
+                !(targetValue instanceof Date)) {
+                result[key] = deepMerge(targetValue, sourceValue);
+            }
+            else {
+                result[key] = sourceValue;
+            }
+        }
+    }
+    return result;
+}
+// Object sort for cache key generation
+export function sortObjectKeys(obj) {
+    return Object.keys(obj)
+        .sort()
+        .reduce((acc, key) => {
+        const value = obj[key];
+        if (value !== null && typeof value === 'object' && !Array.isArray(value)) {
+            acc[key] = sortObjectKeys(value);
+        }
+        else {
+            acc[key] = value;
+        }
+        return acc;
+    }, {});
+}
+// Validate with Zod schema
+export function validate(schema, data) {
+    return schema.parse(data);
+}
+// Safe validate (returns result instead of throwing)
+export function safeValidate(schema, data) {
+    const result = schema.safeParse(data);
+    if (result.success) {
+        return { success: true, data: result.data };
+    }
+    return { success: false, error: result.error };
+}
+// Required fields check
+export function requireFields(obj, fields) {
+    return fields.filter(field => {
+        const value = obj[field];
+        return value === undefined || value === null;
+    });
+}
+// isValidUUID
+export function isValidUUID(str) {
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+    return uuidRegex.test(str);
+}
+// isValidEmail
+export function isValidEmail(email) {
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    return emailRegex.test(email);
+}