@looopy-ai/core 1.0.1

package/dist/stores/filesystem/filesystem-message-store.js

@@ -0,0 +1,149 @@
+import { mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export class FileSystemMessageStore {
+    basePath;
+    agentId;
+    messageIndex = 0;
+    constructor(config) {
+        this.basePath = config.basePath || './_agent_store';
+        this.agentId = config.agentId;
+    }
+    async append(contextId, messages) {
+        const messagesDir = this.getMessagesDir(contextId);
+        await mkdir(messagesDir, { recursive: true });
+        const currentCount = await this.getCount(contextId);
+        for (let i = 0; i < messages.length; i++) {
+            const message = messages[i];
+            const index = currentCount + i;
+            const timestamp = new Date().toISOString();
+            const storedMessage = {
+                ...message,
+                id: `${contextId}-${index}`,
+                contextId,
+                index,
+                timestamp,
+            };
+            const filename = this.getMessageFilename(timestamp, index);
+            const filePath = join(messagesDir, filename);
+            await writeFile(filePath, JSON.stringify(storedMessage, null, 2), 'utf-8');
+        }
+    }
+    async getRecent(contextId, options) {
+        const allMessages = await this.loadMessages(contextId);
+        if (!options?.maxMessages && !options?.maxTokens) {
+            return allMessages.map(this.toMessage);
+        }
+        let messages = allMessages;
+        if (options.maxMessages !== undefined) {
+            messages = messages.slice(-options.maxMessages);
+        }
+        if (options.maxTokens !== undefined) {
+            let totalTokens = 0;
+            const result = [];
+            for (let i = messages.length - 1; i >= 0; i--) {
+                const message = messages[i];
+                const estimatedTokens = message.tokens || this.estimateTokens(message);
+                if (totalTokens + estimatedTokens > options.maxTokens && result.length > 0) {
+                    break;
+                }
+                result.unshift(message);
+                totalTokens += estimatedTokens;
+            }
+            messages = result;
+        }
+        return messages.map(this.toMessage);
+    }
+    async getAll(contextId) {
+        const messages = await this.loadMessages(contextId);
+        return messages.map(this.toMessage);
+    }
+    async getCount(contextId) {
+        try {
+            const messagesDir = this.getMessagesDir(contextId);
+            const files = await readdir(messagesDir);
+            return files.filter((f) => f.endsWith('.json')).length;
+        }
+        catch {
+            return 0;
+        }
+    }
+    async getRange(contextId, startIndex, endIndex) {
+        const allMessages = await this.loadMessages(contextId);
+        const messages = allMessages.filter((m) => m.index >= startIndex && m.index <= endIndex);
+        return messages.map(this.toMessage);
+    }
+    async compact(contextId, options) {
+        const allMessages = await this.loadMessages(contextId);
+        const keepRecent = options?.keepRecent || 20;
+        if (allMessages.length <= keepRecent) {
+            return {
+                summaryMessages: [],
+                compactedRange: { start: 0, end: 0 },
+                tokensSaved: 0,
+            };
+        }
+        const toDelete = allMessages.slice(0, -keepRecent);
+        const messagesDir = this.getMessagesDir(contextId);
+        for (const message of toDelete) {
+            const filename = this.getMessageFilename(message.timestamp, message.index);
+            const filePath = join(messagesDir, filename);
+            await rm(filePath, { force: true });
+        }
+        const tokensFreed = toDelete.reduce((sum, m) => sum + (m.tokens || this.estimateTokens(m)), 0);
+        return {
+            summaryMessages: [],
+            compactedRange: {
+                start: toDelete[0]?.index || 0,
+                end: toDelete[toDelete.length - 1]?.index || 0,
+            },
+            tokensSaved: tokensFreed,
+        };
+    }
+    async clear(contextId) {
+        try {
+            const messagesDir = this.getMessagesDir(contextId);
+            await rm(messagesDir, { recursive: true, force: true });
+        }
+        catch {
+        }
+    }
+    getMessagesDir(contextId) {
+        const safeAgentId = this.sanitizeName(this.agentId);
+        const safeContextId = this.sanitizeName(contextId);
+        return join(this.basePath, `agent=${safeAgentId}`, `context=${safeContextId}`, 'messages');
+    }
+    getMessageFilename(timestamp, index) {
+        const safeTimestamp = timestamp.replace(/:/g, '-').replace(/\./g, '_');
+        return `${safeTimestamp}-${String(index).padStart(3, '0')}-${String(this.messageIndex++).padStart(6, '0')}.json`;
+    }
+    async loadMessages(contextId) {
+        try {
+            const messagesDir = this.getMessagesDir(contextId);
+            const files = await readdir(messagesDir);
+            const messages = [];
+            for (const file of files) {
+                if (!file.endsWith('.json'))
+                    continue;
+                const filePath = join(messagesDir, file);
+                const content = await readFile(filePath, 'utf-8');
+                const message = JSON.parse(content);
+                messages.push(message);
+            }
+            return messages.sort((a, b) => a.index - b.index);
+        }
+        catch {
+            return [];
+        }
+    }
+    toMessage(stored) {
+        const { id: _id, contextId: _contextId, index: _index, timestamp: _timestamp, tokens: _tokens, tags: _tags, compacted: _compacted, summarizedRange: _summarizedRange, ...message } = stored;
+        return message;
+    }
+    estimateTokens(message) {
+        const content = typeof message.content === 'string' ? message.content : JSON.stringify(message.content);
+        return Math.ceil(content.length / 4);
+    }
+    sanitizeName(name) {
+        return name.replace(/[^a-zA-Z0-9_-]/g, '_');
+    }
+}

package/dist/stores/filesystem/filesystem-task-state-store.d.ts

@@ -0,0 +1,27 @@
+import type { PersistedLoopState, TaskStateStore } from '../../types/state';
+export interface FileSystemStateStoreConfig {
+    basePath?: string;
+    defaultTTL?: number;
+}
+export declare class FileSystemStateStore implements TaskStateStore {
+    private basePath;
+    private defaultTTL;
+    constructor(config?: FileSystemStateStoreConfig);
+    save(taskId: string, state: PersistedLoopState): Promise<void>;
+    load(taskId: string): Promise<PersistedLoopState | null>;
+    exists(taskId: string): Promise<boolean>;
+    delete(taskId: string): Promise<void>;
+    listTasks(filter?: {
+        agentId?: string;
+        contextId?: string;
+        completedAfter?: Date;
+    }): Promise<string[]>;
+    private getTaskIdsFromDir;
+    private processStateFile;
+    setTTL(taskId: string, ttlSeconds: number): Promise<void>;
+    private getStateFilePath;
+    private findStateFile;
+    private getAgentDirectories;
+    private getContextDirectories;
+    private sanitizeName;
+}

package/dist/stores/filesystem/filesystem-task-state-store.js

@@ -0,0 +1,220 @@
+import { mkdir, readdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export class FileSystemStateStore {
+    basePath;
+    defaultTTL;
+    constructor(config = {}) {
+        this.basePath = config.basePath || './_agent_store';
+        this.defaultTTL = config.defaultTTL || 24 * 60 * 60;
+    }
+    async save(taskId, state) {
+        const filePath = this.getStateFilePath(state.agentId, state.contextId, taskId);
+        await mkdir(join(filePath, '..'), { recursive: true });
+        const stateWithMeta = {
+            ...state,
+            _metadata: {
+                savedAt: new Date().toISOString(),
+                expiresAt: new Date(Date.now() + this.defaultTTL * 1000).toISOString(),
+            },
+        };
+        await writeFile(filePath, JSON.stringify(stateWithMeta, null, 2), 'utf-8');
+    }
+    async load(taskId) {
+        try {
+            const filePath = await this.findStateFile(taskId);
+            if (!filePath) {
+                return null;
+            }
+            const content = await readFile(filePath, 'utf-8');
+            const stateWithMeta = JSON.parse(content);
+            if (stateWithMeta._metadata?.expiresAt) {
+                const expiresAt = new Date(stateWithMeta._metadata.expiresAt);
+                if (expiresAt < new Date()) {
+                    await rm(filePath);
+                    return null;
+                }
+            }
+            const { _metadata, ...state } = stateWithMeta;
+            return state;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async exists(taskId) {
+        const filePath = await this.findStateFile(taskId);
+        if (!filePath) {
+            return false;
+        }
+        try {
+            const content = await readFile(filePath, 'utf-8');
+            const stateWithMeta = JSON.parse(content);
+            if (stateWithMeta._metadata?.expiresAt) {
+                const expiresAt = new Date(stateWithMeta._metadata.expiresAt);
+                if (expiresAt < new Date()) {
+                    await rm(filePath);
+                    return false;
+                }
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async delete(taskId) {
+        const filePath = await this.findStateFile(taskId);
+        if (filePath) {
+            await rm(filePath);
+        }
+    }
+    async listTasks(filter) {
+        const taskIds = [];
+        try {
+            const agentDirs = await this.getAgentDirectories(filter?.agentId);
+            for (const agentDir of agentDirs) {
+                const contextDirs = await this.getContextDirectories(agentDir, filter?.contextId);
+                for (const contextDir of contextDirs) {
+                    const dirTaskIds = await this.getTaskIdsFromDir(contextDir, filter);
+                    taskIds.push(...dirTaskIds);
+                }
+            }
+        }
+        catch {
+        }
+        return taskIds;
+    }
+    async getTaskIdsFromDir(contextDir, filter) {
+        const taskIds = [];
+        const taskDir = join(contextDir, 'task');
+        try {
+            const files = await readdir(taskDir);
+            for (const file of files) {
+                if (!file.endsWith('.json'))
+                    continue;
+                const taskId = await this.processStateFile(join(taskDir, file), filter);
+                if (taskId) {
+                    taskIds.push(taskId);
+                }
+            }
+        }
+        catch {
+        }
+        return taskIds;
+    }
+    async processStateFile(filePath, filter) {
+        try {
+            const content = await readFile(filePath, 'utf-8');
+            const stateWithMeta = JSON.parse(content);
+            if (stateWithMeta._metadata?.expiresAt) {
+                const expiresAt = new Date(stateWithMeta._metadata.expiresAt);
+                if (expiresAt < new Date()) {
+                    await rm(filePath);
+                    return null;
+                }
+            }
+            if (filter?.completedAfter && stateWithMeta.completed) {
+                const lastActivity = new Date(stateWithMeta.lastActivity);
+                if (lastActivity < filter.completedAfter) {
+                    return null;
+                }
+            }
+            return stateWithMeta.taskId;
+        }
+        catch {
+            return null;
+        }
+    }
+    async setTTL(taskId, ttlSeconds) {
+        const filePath = await this.findStateFile(taskId);
+        if (!filePath) {
+            return;
+        }
+        const content = await readFile(filePath, 'utf-8');
+        const stateWithMeta = JSON.parse(content);
+        stateWithMeta._metadata = {
+            ...stateWithMeta._metadata,
+            expiresAt: new Date(Date.now() + ttlSeconds * 1000).toISOString(),
+        };
+        await writeFile(filePath, JSON.stringify(stateWithMeta, null, 2), 'utf-8');
+    }
+    getStateFilePath(agentId, contextId, taskId) {
+        const safeAgentId = this.sanitizeName(agentId);
+        const safeContextId = this.sanitizeName(contextId);
+        const safeTaskId = this.sanitizeName(taskId);
+        return join(this.basePath, `agent=${safeAgentId}`, `context=${safeContextId}`, 'task', `${safeTaskId}.json`);
+    }
+    async findStateFile(taskId) {
+        try {
+            const agentDirs = await this.getAgentDirectories();
+            for (const agentDir of agentDirs) {
+                const contextDirs = await this.getContextDirectories(agentDir);
+                for (const contextDir of contextDirs) {
+                    const safeTaskId = this.sanitizeName(taskId);
+                    const filePath = join(contextDir, 'task', `${safeTaskId}.json`);
+                    try {
+                        await stat(filePath);
+                        return filePath;
+                    }
+                    catch {
+                    }
+                }
+            }
+        }
+        catch {
+        }
+        return null;
+    }
+    async getAgentDirectories(agentId) {
+        try {
+            const entries = await readdir(this.basePath);
+            const agentDirs = [];
+            for (const entry of entries) {
+                if (entry.startsWith('agent=')) {
+                    if (agentId) {
+                        const safeAgentId = this.sanitizeName(agentId);
+                        if (entry === `agent=${safeAgentId}`) {
+                            agentDirs.push(join(this.basePath, entry));
+                        }
+                    }
+                    else {
+                        agentDirs.push(join(this.basePath, entry));
+                    }
+                }
+            }
+            return agentDirs;
+        }
+        catch {
+            return [];
+        }
+    }
+    async getContextDirectories(agentDir, contextId) {
+        try {
+            const entries = await readdir(agentDir);
+            const contextDirs = [];
+            for (const entry of entries) {
+                if (entry.startsWith('context=')) {
+                    if (contextId) {
+                        const safeContextId = this.sanitizeName(contextId);
+                        if (entry === `context=${safeContextId}`) {
+                            contextDirs.push(join(agentDir, entry));
+                        }
+                    }
+                    else {
+                        contextDirs.push(join(agentDir, entry));
+                    }
+                }
+            }
+            return contextDirs;
+        }
+        catch {
+            return [];
+        }
+    }
+    sanitizeName(name) {
+        return name.replace(/[^a-zA-Z0-9_-]/g, '_');
+    }
+}

package/dist/stores/filesystem/index.d.ts

@@ -0,0 +1,10 @@
+export type { FileSystemAgentStoreConfig } from './filesystem-agent-store';
+export { FileSystemAgentStore } from './filesystem-agent-store';
+export type { FileSystemArtifactStoreConfig } from './filesystem-artifact-store';
+export { FileSystemArtifactStore } from './filesystem-artifact-store';
+export type { FileSystemContextStoreConfig } from './filesystem-context-store';
+export { FileSystemContextStore } from './filesystem-context-store';
+export type { FileSystemMessageStoreConfig } from './filesystem-message-store';
+export { FileSystemMessageStore } from './filesystem-message-store';
+export type { FileSystemStateStoreConfig } from './filesystem-task-state-store';
+export { FileSystemStateStore } from './filesystem-task-state-store';

package/dist/stores/filesystem/index.js

@@ -0,0 +1,5 @@
+export { FileSystemAgentStore } from './filesystem-agent-store';
+export { FileSystemArtifactStore } from './filesystem-artifact-store';
+export { FileSystemContextStore } from './filesystem-context-store';
+export { FileSystemMessageStore } from './filesystem-message-store';
+export { FileSystemStateStore } from './filesystem-task-state-store';

package/dist/stores/index.d.ts

@@ -0,0 +1,5 @@
+export * from './artifacts';
+export * from './filesystem';
+export * from './filesystem';
+export * from './memory/memory-state-store';
+export * from './messages';

package/dist/stores/index.js

@@ -0,0 +1,5 @@
+export * from './artifacts';
+export * from './filesystem';
+export * from './filesystem';
+export * from './memory/memory-state-store';
+export * from './messages';

package/dist/stores/memory/memory-state-store.d.ts

@@ -0,0 +1,15 @@
+import type { PersistedLoopState, TaskStateStore } from '../../types/state';
+export declare class InMemoryStateStore implements TaskStateStore {
+    private states;
+    save(taskId: string, state: PersistedLoopState): Promise<void>;
+    load(taskId: string): Promise<PersistedLoopState | null>;
+    exists(taskId: string): Promise<boolean>;
+    delete(taskId: string): Promise<void>;
+    listTasks(filter?: {
+        agentId?: string;
+        contextId?: string;
+        completedAfter?: Date;
+    }): Promise<string[]>;
+    setTTL(taskId: string, ttlSeconds: number): Promise<void>;
+    private cleanup;
+}

package/dist/stores/memory/memory-state-store.js

@@ -0,0 +1,55 @@
+export class InMemoryStateStore {
+    states = new Map();
+    async save(taskId, state) {
+        this.states.set(taskId, {
+            state: JSON.parse(JSON.stringify(state)),
+            expiresAt: Date.now() + 24 * 60 * 60 * 1000,
+        });
+    }
+    async load(taskId) {
+        this.cleanup();
+        const entry = this.states.get(taskId);
+        return entry ? JSON.parse(JSON.stringify(entry.state)) : null;
+    }
+    async exists(taskId) {
+        this.cleanup();
+        return this.states.has(taskId);
+    }
+    async delete(taskId) {
+        this.states.delete(taskId);
+    }
+    async listTasks(filter) {
+        this.cleanup();
+        const taskIds = [];
+        for (const [taskId, entry] of this.states.entries()) {
+            const state = entry.state;
+            if (filter) {
+                if (filter.agentId && state.agentId !== filter.agentId)
+                    continue;
+                if (filter.contextId && state.contextId !== filter.contextId)
+                    continue;
+                if (filter.completedAfter) {
+                    const lastActivity = new Date(state.lastActivity);
+                    if (lastActivity <= filter.completedAfter)
+                        continue;
+                }
+            }
+            taskIds.push(taskId);
+        }
+        return taskIds;
+    }
+    async setTTL(taskId, ttlSeconds) {
+        const entry = this.states.get(taskId);
+        if (entry) {
+            entry.expiresAt = Date.now() + ttlSeconds * 1000;
+        }
+    }
+    cleanup() {
+        const now = Date.now();
+        for (const [taskId, entry] of this.states.entries()) {
+            if (entry.expiresAt < now) {
+                this.states.delete(taskId);
+            }
+        }
+    }
+}

package/dist/stores/messages/hybrid-message-store.d.ts

@@ -0,0 +1,29 @@
+import type { Message } from '../../types/message';
+import type { CompactionOptions, CompactionResult, MessageStore } from './interfaces';
+export type SyncStrategy = 'immediate' | 'batch' | 'end-of-session';
+export interface HybridConfig {
+    messageStore: MessageStore;
+    memoryStore: MessageStore;
+    syncStrategy?: SyncStrategy;
+    includeMemoryContext?: boolean;
+}
+export declare class HybridMessageStore implements MessageStore {
+    private config;
+    constructor(config: HybridConfig);
+    append(contextId: string, messages: Message[]): Promise<void>;
+    getRecent(contextId: string, options?: {
+        maxMessages?: number;
+        maxTokens?: number;
+    }): Promise<Message[]>;
+    getAll(contextId: string): Promise<Message[]>;
+    getCount(contextId: string): Promise<number>;
+    getRange(contextId: string, startIndex: number, endIndex: number): Promise<Message[]>;
+    compact(contextId: string, options?: CompactionOptions): Promise<CompactionResult>;
+    clear(contextId: string): Promise<void>;
+    syncToMemory(contextId: string): Promise<void>;
+    getMemoryContext(contextId: string): Promise<Message[]>;
+    getRawMessages(contextId: string, options?: {
+        maxMessages?: number;
+        maxTokens?: number;
+    }): Promise<Message[]>;
+}

package/dist/stores/messages/hybrid-message-store.js

@@ -0,0 +1,72 @@
+export class HybridMessageStore {
+    config;
+    constructor(config) {
+        this.config = {
+            messageStore: config.messageStore,
+            memoryStore: config.memoryStore,
+            syncStrategy: config.syncStrategy || 'immediate',
+            includeMemoryContext: config.includeMemoryContext ?? true,
+        };
+    }
+    async append(contextId, messages) {
+        await this.config.messageStore.append(contextId, messages);
+        if (this.config.syncStrategy === 'immediate') {
+            await this.config.memoryStore.append(contextId, messages);
+        }
+    }
+    async getRecent(contextId, options) {
+        const messages = await this.config.messageStore.getRecent(contextId, options);
+        if (!this.config.includeMemoryContext) {
+            return messages;
+        }
+        try {
+            const memories = await this.config.memoryStore.getRecent(contextId, {
+                maxMessages: 5,
+            });
+            return [...memories, ...messages];
+        }
+        catch (error) {
+            console.error('Failed to get memory context:', error);
+            return messages;
+        }
+    }
+    async getAll(contextId) {
+        return this.config.messageStore.getAll(contextId);
+    }
+    async getCount(contextId) {
+        return this.config.messageStore.getCount(contextId);
+    }
+    async getRange(contextId, startIndex, endIndex) {
+        return this.config.messageStore.getRange(contextId, startIndex, endIndex);
+    }
+    async compact(contextId, options) {
+        const localResult = await this.config.messageStore.compact(contextId, options);
+        try {
+            await this.config.memoryStore.compact(contextId, options);
+        }
+        catch (error) {
+            console.error('Failed to compact memory store:', error);
+        }
+        return localResult;
+    }
+    async clear(contextId) {
+        await Promise.all([
+            this.config.messageStore.clear(contextId),
+            this.config.memoryStore.clear(contextId),
+        ]);
+    }
+    async syncToMemory(contextId) {
+        const messages = await this.config.messageStore.getAll(contextId);
+        const memoryCount = await this.config.memoryStore.getCount(contextId);
+        if (messages.length > memoryCount) {
+            const newMessages = messages.slice(memoryCount);
+            await this.config.memoryStore.append(contextId, newMessages);
+        }
+    }
+    async getMemoryContext(contextId) {
+        return this.config.memoryStore.getRecent(contextId, { maxMessages: 10 });
+    }
+    async getRawMessages(contextId, options) {
+        return this.config.messageStore.getRecent(contextId, options);
+    }
+}

package/dist/stores/messages/index.d.ts

@@ -0,0 +1,4 @@
+export * from './hybrid-message-store';
+export * from './interfaces';
+export * from './mem0-message-store';
+export * from './memory-message-store';

package/dist/stores/messages/index.js

@@ -0,0 +1,4 @@
+export * from './hybrid-message-store';
+export * from './interfaces';
+export * from './mem0-message-store';
+export * from './memory-message-store';

package/dist/stores/messages/interfaces.d.ts

@@ -0,0 +1,42 @@
+import type { Message } from '../../types/message';
+export interface StoredMessage extends Message {
+    id: string;
+    contextId: string;
+    index: number;
+    timestamp: string;
+    tokens?: number;
+    tags?: string[];
+    compacted?: boolean;
+    summarizedRange?: {
+        start: number;
+        end: number;
+    };
+}
+export interface MessageStore {
+    append(contextId: string, messages: Message[]): Promise<void>;
+    getRecent(contextId: string, options?: {
+        maxMessages?: number;
+        maxTokens?: number;
+    }): Promise<Message[]>;
+    getAll(contextId: string): Promise<Message[]>;
+    getCount(contextId: string): Promise<number>;
+    getRange(contextId: string, startIndex: number, endIndex: number): Promise<Message[]>;
+    compact(contextId: string, options?: CompactionOptions): Promise<CompactionResult>;
+    clear(contextId: string): Promise<void>;
+}
+export interface CompactionOptions {
+    keepRecent?: number;
+    targetTokens?: number;
+    strategy?: 'sliding-window' | 'summarization' | 'hierarchical';
+    summaryPrompt?: string;
+}
+export interface CompactionResult {
+    summaryMessages: Message[];
+    compactedRange: {
+        start: number;
+        end: number;
+    };
+    tokensSaved: number;
+}
+export declare function estimateTokens(content: string | unknown): number;
+export declare function trimToTokenBudget<T extends Message>(messages: T[], maxTokens: number): T[];

package/dist/stores/messages/interfaces.js

@@ -0,0 +1,18 @@
+export function estimateTokens(content) {
+    const text = typeof content === 'string' ? content : JSON.stringify(content);
+    return Math.ceil(text.length / 4);
+}
+export function trimToTokenBudget(messages, maxTokens) {
+    let total = 0;
+    const result = [];
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        const tokens = estimateTokens(msg.content);
+        if (total + tokens > maxTokens) {
+            break;
+        }
+        result.unshift(msg);
+        total += tokens;
+    }
+    return result;
+}