@looopy-ai/core 1.0.1

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

@@ -0,0 +1,325 @@
+import { randomUUID } from 'node:crypto';
+import { appendFile, mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export class FileSystemArtifactStore {
+    basePath;
+    agentId;
+    constructor(config) {
+        this.basePath = config.basePath || './_agent_store';
+        this.agentId = config.agentId;
+    }
+    async createFileArtifact(params) {
+        const artifactId = params.artifactId || randomUUID();
+        const artifactDir = this.getArtifactDir(params.contextId, artifactId);
+        const existing = await this.getArtifact(params.contextId, artifactId);
+        if (existing && !params.override) {
+            throw new Error(`Artifact already exists: ${artifactId}. ` +
+                `Use override: true to replace it, or use a different artifactId.`);
+        }
+        if (existing && params.override) {
+            try {
+                await rm(artifactDir, { recursive: true, force: true });
+            }
+            catch {
+            }
+        }
+        await mkdir(artifactDir, { recursive: true });
+        const contentPath = join(artifactDir, 'content.txt');
+        await writeFile(contentPath, '', 'utf-8');
+        const now = new Date().toISOString();
+        const artifact = {
+            type: 'file',
+            artifactId,
+            taskId: params.taskId,
+            contextId: params.contextId,
+            name: params.name,
+            description: params.description,
+            mimeType: params.mimeType,
+            encoding: params.encoding || 'utf-8',
+            chunks: [],
+            totalChunks: 0,
+            totalSize: 0,
+            status: 'building',
+            version: existing && params.override ? existing.version + 1 : 1,
+            operations: [
+                {
+                    operationId: `op-${Date.now()}`,
+                    type: params.override ? 'reset' : 'create',
+                    timestamp: now,
+                },
+            ],
+            createdAt: existing ? existing.createdAt : now,
+            updatedAt: now,
+        };
+        await this.saveMetadata(artifactDir, artifact);
+        return artifactId;
+    }
+    async appendFileChunk(contextId, artifactId, chunk, options) {
+        const artifact = await this.getArtifact(contextId, artifactId);
+        if (!artifact || artifact.type !== 'file') {
+            throw new Error(`File artifact not found: ${artifactId} in context ${contextId}`);
+        }
+        const artifactDir = this.getArtifactDir(contextId, artifactId);
+        const contentPath = join(artifactDir, 'content.txt');
+        const chunkIndex = artifact.chunks.length;
+        await appendFile(contentPath, chunk, 'utf-8');
+        const now = new Date().toISOString();
+        const chunkSize = Buffer.byteLength(chunk, 'utf-8');
+        artifact.chunks.push({
+            index: chunkIndex,
+            data: chunk,
+            size: chunkSize,
+            timestamp: now,
+        });
+        artifact.totalChunks++;
+        artifact.totalSize += chunkSize;
+        artifact.updatedAt = now;
+        if (options?.isLastChunk) {
+            artifact.status = 'complete';
+            artifact.completedAt = now;
+        }
+        artifact.operations.push({
+            operationId: `op-${Date.now()}`,
+            type: 'append',
+            timestamp: now,
+        });
+        await this.saveMetadata(artifactDir, artifact);
+    }
+    async getFileContent(contextId, artifactId) {
+        const artifact = await this.getArtifact(contextId, artifactId);
+        if (!artifact || artifact.type !== 'file') {
+            throw new Error(`File artifact not found: ${artifactId} in context ${contextId}`);
+        }
+        const artifactDir = this.getArtifactDir(contextId, artifactId);
+        const contentPath = join(artifactDir, 'content.txt');
+        try {
+            return await readFile(contentPath, 'utf-8');
+        }
+        catch (error) {
+            if (artifact.chunks.length > 0) {
+                return artifact.chunks.map((c) => c.data).join('');
+            }
+            throw error;
+        }
+    }
+    async createDataArtifact(params) {
+        const artifactId = params.artifactId || randomUUID();
+        const artifactDir = this.getArtifactDir(params.contextId, artifactId);
+        const existing = await this.getArtifact(params.contextId, artifactId);
+        if (existing && !params.override) {
+            throw new Error(`Artifact already exists: ${artifactId}. ` +
+                `Use override: true to replace it, or use a different artifactId.`);
+        }
+        if (existing && params.override) {
+            try {
+                await rm(artifactDir, { recursive: true, force: true });
+            }
+            catch {
+            }
+        }
+        await mkdir(artifactDir, { recursive: true });
+        const now = new Date().toISOString();
+        const artifact = {
+            type: 'data',
+            artifactId,
+            taskId: params.taskId,
+            contextId: params.contextId,
+            name: params.name,
+            description: params.description,
+            data: {},
+            status: 'building',
+            version: existing && params.override ? existing.version + 1 : 1,
+            operations: [
+                {
+                    operationId: `op-${Date.now()}`,
+                    type: params.override ? 'reset' : 'create',
+                    timestamp: now,
+                },
+            ],
+            createdAt: existing ? existing.createdAt : now,
+            updatedAt: now,
+        };
+        await this.saveMetadata(artifactDir, artifact);
+        await writeFile(join(artifactDir, 'data.json'), '{}', 'utf-8');
+        return artifactId;
+    }
+    async writeData(contextId, artifactId, data) {
+        const artifact = await this.getArtifact(contextId, artifactId);
+        if (!artifact || artifact.type !== 'data') {
+            throw new Error(`Data artifact not found: ${artifactId} in context ${contextId}`);
+        }
+        const artifactDir = this.getArtifactDir(contextId, artifactId);
+        const now = new Date().toISOString();
+        await writeFile(join(artifactDir, 'data.json'), JSON.stringify(data, null, 2), 'utf-8');
+        artifact.data = data;
+        artifact.status = 'complete';
+        artifact.updatedAt = now;
+        artifact.completedAt = now;
+        artifact.operations.push({
+            operationId: `op-${Date.now()}`,
+            type: 'replace',
+            timestamp: now,
+        });
+        await this.saveMetadata(artifactDir, artifact);
+    }
+    async getDataContent(contextId, artifactId) {
+        const artifact = await this.getArtifact(contextId, artifactId);
+        if (!artifact || artifact.type !== 'data') {
+            throw new Error(`Data artifact not found: ${artifactId} in context ${contextId}`);
+        }
+        const artifactDir = this.getArtifactDir(contextId, artifactId);
+        try {
+            const dataPath = join(artifactDir, 'data.json');
+            const content = await readFile(dataPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch {
+            return artifact.data;
+        }
+    }
+    async createDatasetArtifact(params) {
+        const artifactId = params.artifactId || randomUUID();
+        const artifactDir = this.getArtifactDir(params.contextId, artifactId);
+        const existing = await this.getArtifact(params.contextId, artifactId);
+        if (existing && !params.override) {
+            throw new Error(`Artifact already exists: ${artifactId}. ` +
+                `Use override: true to replace it, or use a different artifactId.`);
+        }
+        if (existing && params.override) {
+            try {
+                await rm(artifactDir, { recursive: true, force: true });
+            }
+            catch {
+            }
+        }
+        await mkdir(artifactDir, { recursive: true });
+        const now = new Date().toISOString();
+        const artifact = {
+            type: 'dataset',
+            artifactId,
+            taskId: params.taskId,
+            contextId: params.contextId,
+            name: params.name,
+            description: params.description,
+            schema: params.schema,
+            rows: [],
+            totalChunks: 0,
+            totalSize: 0,
+            status: 'building',
+            version: existing && params.override ? existing.version + 1 : 1,
+            operations: [
+                {
+                    operationId: `op-${Date.now()}`,
+                    type: params.override ? 'reset' : 'create',
+                    timestamp: now,
+                },
+            ],
+            createdAt: existing ? existing.createdAt : now,
+            updatedAt: now,
+        };
+        await this.saveMetadata(artifactDir, artifact);
+        await writeFile(join(artifactDir, 'rows.jsonl'), '', 'utf-8');
+        return artifactId;
+    }
+    async appendDatasetBatch(contextId, artifactId, rows, options) {
+        const artifact = await this.getArtifact(contextId, artifactId);
+        if (!artifact || artifact.type !== 'dataset') {
+            throw new Error(`Dataset artifact not found: ${artifactId} in context ${contextId}`);
+        }
+        const artifactDir = this.getArtifactDir(contextId, artifactId);
+        const now = new Date().toISOString();
+        const rowsPath = join(artifactDir, 'rows.jsonl');
+        const lines = `${rows.map((row) => JSON.stringify(row)).join('\n')}\n`;
+        await appendFile(rowsPath, lines, 'utf-8');
+        artifact.rows.push(...rows);
+        artifact.totalChunks++;
+        artifact.totalSize += rows.length;
+        artifact.updatedAt = now;
+        if (options?.isLastBatch) {
+            artifact.status = 'complete';
+            artifact.completedAt = now;
+        }
+        artifact.operations.push({
+            operationId: `op-${Date.now()}`,
+            type: 'append',
+            timestamp: now,
+        });
+        await this.saveMetadata(artifactDir, artifact);
+    }
+    async getDatasetRows(contextId, artifactId) {
+        const artifact = await this.getArtifact(contextId, artifactId);
+        if (!artifact || artifact.type !== 'dataset') {
+            throw new Error(`Dataset artifact not found: ${artifactId} in context ${contextId}`);
+        }
+        const artifactDir = this.getArtifactDir(contextId, artifactId);
+        try {
+            const rowsPath = join(artifactDir, 'rows.jsonl');
+            const content = await readFile(rowsPath, 'utf-8');
+            const lines = content
+                .trim()
+                .split('\n')
+                .filter((line) => line.length > 0);
+            return lines.map((line) => JSON.parse(line));
+        }
+        catch {
+            return artifact.rows;
+        }
+    }
+    async getArtifact(contextId, artifactId) {
+        const artifactDir = this.getArtifactDir(contextId, artifactId);
+        return this.loadMetadata(artifactDir);
+    }
+    async deleteArtifact(contextId, artifactId) {
+        const artifact = await this.getArtifact(contextId, artifactId);
+        if (!artifact) {
+            throw new Error(`Artifact not found: ${artifactId} in context ${contextId}`);
+        }
+        const artifactDir = this.getArtifactDir(contextId, artifactId);
+        await rm(artifactDir, { recursive: true, force: true });
+    }
+    async listArtifacts(contextId, taskId) {
+        const results = [];
+        const contextDir = join(this.basePath, `agent=${this.agentId}`, `context=${contextId}`, 'artifacts');
+        try {
+            const entries = await readdir(contextDir);
+            for (const artifactId of entries) {
+                const artifact = await this.getArtifact(contextId, artifactId);
+                if (!artifact)
+                    continue;
+                if (taskId && artifact.taskId !== taskId)
+                    continue;
+                results.push(artifactId);
+            }
+        }
+        catch {
+            return [];
+        }
+        return results;
+    }
+    async queryArtifacts(query) {
+        if (!query.contextId) {
+            throw new Error('contextId is required for queryArtifacts');
+        }
+        return this.listArtifacts(query.contextId, query.taskId);
+    }
+    async getTaskArtifacts(_taskId) {
+        throw new Error('getTaskArtifacts not supported for filesystem store. Use listArtifacts with contextId instead.');
+    }
+    getArtifactDir(contextId, artifactId) {
+        return join(this.basePath, `agent=${this.agentId}`, `context=${contextId}`, 'artifacts', artifactId);
+    }
+    async saveMetadata(artifactDir, artifact) {
+        const metadataPath = join(artifactDir, 'metadata.json');
+        await writeFile(metadataPath, JSON.stringify(artifact, null, 2), 'utf-8');
+    }
+    async loadMetadata(artifactDir) {
+        try {
+            const metadataPath = join(artifactDir, 'metadata.json');
+            const content = await readFile(metadataPath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch {
+            return null;
+        }
+    }
+}

package/dist/stores/filesystem/filesystem-context-store.d.ts

@@ -0,0 +1,37 @@
+import type { ContextState, ContextStore } from '../../types/state';
+export interface FileSystemContextStoreConfig {
+    basePath?: string;
+    defaultLockTTL?: number;
+}
+export declare class FileSystemContextStore implements ContextStore {
+    private basePath;
+    private defaultLockTTL;
+    constructor(config?: FileSystemContextStoreConfig);
+    save(state: ContextState): Promise<void>;
+    load(contextId: string): Promise<ContextState | null>;
+    exists(contextId: string): Promise<boolean>;
+    delete(contextId: string): Promise<void>;
+    list(filter?: {
+        agentId?: string;
+        ownerId?: string;
+        status?: ContextState['status'];
+        tags?: string[];
+        createdAfter?: Date;
+        createdBefore?: Date;
+        updatedAfter?: Date;
+        limit?: number;
+        offset?: number;
+    }): Promise<ContextState[]>;
+    search(query: string, filter?: {
+        agentId?: string;
+        ownerId?: string;
+    }): Promise<ContextState[]>;
+    acquireLock(contextId: string, lockOwnerId: string, ttlSeconds?: number): Promise<boolean>;
+    releaseLock(contextId: string, lockOwnerId: string): Promise<void>;
+    refreshLock(contextId: string, lockOwnerId: string, ttlSeconds?: number): Promise<boolean>;
+    isLocked(contextId: string): Promise<boolean>;
+    update(contextId: string, updates: Partial<Omit<ContextState, 'contextId' | 'agentId' | 'createdAt'>>): Promise<void>;
+    private getContextDir;
+    private findContextDirs;
+    private getAllAgentDirs;
+}

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

@@ -0,0 +1,245 @@
+import { mkdir, readdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export class FileSystemContextStore {
+    basePath;
+    defaultLockTTL;
+    constructor(config = {}) {
+        this.basePath = config.basePath || './_agent_store';
+        this.defaultLockTTL = config.defaultLockTTL || 5 * 60;
+    }
+    async save(state) {
+        const contextDir = this.getContextDir(state.agentId, state.contextId);
+        const filePath = join(contextDir, 'context.json');
+        await mkdir(contextDir, { recursive: true });
+        const now = new Date().toISOString();
+        const stateWithTimestamps = {
+            ...state,
+            updatedAt: now,
+            lastActivityAt: now,
+        };
+        await writeFile(filePath, JSON.stringify(stateWithTimestamps, null, 2), 'utf-8');
+    }
+    async load(contextId) {
+        try {
+            const contextDirs = await this.findContextDirs(contextId);
+            if (contextDirs.length === 0) {
+                return null;
+            }
+            const filePath = join(contextDirs[0], 'context.json');
+            const content = await readFile(filePath, 'utf-8');
+            const state = JSON.parse(content);
+            if (state.lockExpiresAt && new Date(state.lockExpiresAt) < new Date()) {
+                state.lockedBy = undefined;
+                state.lockedAt = undefined;
+                state.lockExpiresAt = undefined;
+                await this.save(state);
+            }
+            return state;
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async exists(contextId) {
+        const contextDirs = await this.findContextDirs(contextId);
+        return contextDirs.length > 0;
+    }
+    async delete(contextId) {
+        const contextDirs = await this.findContextDirs(contextId);
+        for (const contextDir of contextDirs) {
+            await rm(contextDir, { recursive: true, force: true });
+        }
+    }
+    async list(filter) {
+        const allContexts = [];
+        const agentDirs = filter?.agentId
+            ? [join(this.basePath, `agent=${filter.agentId}`)]
+            : await this.getAllAgentDirs();
+        for (const agentDir of agentDirs) {
+            try {
+                const entries = await readdir(agentDir, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.isDirectory() && entry.name.startsWith('context=')) {
+                        const contextDir = join(agentDir, entry.name);
+                        const filePath = join(contextDir, 'context.json');
+                        try {
+                            const content = await readFile(filePath, 'utf-8');
+                            const state = JSON.parse(content);
+                            allContexts.push(state);
+                        }
+                        catch (error) {
+                            if (error.code !== 'ENOENT') {
+                                throw error;
+                            }
+                        }
+                    }
+                }
+            }
+            catch (error) {
+                if (error.code !== 'ENOENT') {
+                    throw error;
+                }
+            }
+        }
+        let filtered = allContexts;
+        if (filter?.ownerId) {
+            filtered = filtered.filter((c) => c.ownerId === filter.ownerId);
+        }
+        if (filter?.status) {
+            filtered = filtered.filter((c) => c.status === filter.status);
+        }
+        if (filter?.tags && filter.tags.length > 0) {
+            filtered = filtered.filter((c) => filter.tags?.some((tag) => c.tags?.includes(tag)));
+        }
+        if (filter?.createdAfter) {
+            filtered = filtered.filter((c) => new Date(c.createdAt) >= filter.createdAfter);
+        }
+        if (filter?.createdBefore) {
+            filtered = filtered.filter((c) => new Date(c.createdAt) <= filter.createdBefore);
+        }
+        if (filter?.updatedAfter) {
+            filtered = filtered.filter((c) => new Date(c.updatedAt) >= filter.updatedAfter);
+        }
+        filtered.sort((a, b) => new Date(b.lastActivityAt).getTime() - new Date(a.lastActivityAt).getTime());
+        const offset = filter?.offset || 0;
+        const limit = filter?.limit || filtered.length;
+        return filtered.slice(offset, offset + limit);
+    }
+    async search(query, filter) {
+        const allContexts = await this.list(filter);
+        const queryLower = query.toLowerCase();
+        return allContexts.filter((context) => {
+            const titleMatch = context.title?.toLowerCase().includes(queryLower);
+            const descriptionMatch = context.description?.toLowerCase().includes(queryLower);
+            const tagMatch = context.tags?.some((tag) => tag.toLowerCase().includes(queryLower));
+            return titleMatch || descriptionMatch || tagMatch;
+        });
+    }
+    async acquireLock(contextId, lockOwnerId, ttlSeconds) {
+        const state = await this.load(contextId);
+        if (!state) {
+            throw new Error(`Context not found: ${contextId}`);
+        }
+        if (state.lockedBy && state.lockedBy !== lockOwnerId) {
+            if (state.lockExpiresAt && new Date(state.lockExpiresAt) > new Date()) {
+                return false;
+            }
+        }
+        const now = new Date();
+        const ttl = ttlSeconds || this.defaultLockTTL;
+        const expiresAt = new Date(now.getTime() + ttl * 1000);
+        state.lockedBy = lockOwnerId;
+        state.lockedAt = now.toISOString();
+        state.lockExpiresAt = expiresAt.toISOString();
+        state.status = 'locked';
+        await this.save(state);
+        const contextDir = this.getContextDir(state.agentId, contextId);
+        const lockPath = join(contextDir, 'context.lock');
+        const lockFile = {
+            lockOwnerId,
+            lockedAt: state.lockedAt,
+            expiresAt: state.lockExpiresAt,
+        };
+        await writeFile(lockPath, JSON.stringify(lockFile, null, 2), 'utf-8');
+        return true;
+    }
+    async releaseLock(contextId, lockOwnerId) {
+        const state = await this.load(contextId);
+        if (!state) {
+            throw new Error(`Context not found: ${contextId}`);
+        }
+        if (state.lockedBy !== lockOwnerId) {
+            throw new Error(`Lock is owned by ${state.lockedBy}, cannot release`);
+        }
+        state.lockedBy = undefined;
+        state.lockedAt = undefined;
+        state.lockExpiresAt = undefined;
+        state.status = 'active';
+        await this.save(state);
+        const contextDir = this.getContextDir(state.agentId, contextId);
+        const lockPath = join(contextDir, 'context.lock');
+        await rm(lockPath, { force: true });
+    }
+    async refreshLock(contextId, lockOwnerId, ttlSeconds) {
+        const state = await this.load(contextId);
+        if (!state) {
+            throw new Error(`Context not found: ${contextId}`);
+        }
+        if (state.lockedBy !== lockOwnerId) {
+            return false;
+        }
+        const ttl = ttlSeconds || this.defaultLockTTL;
+        const expiresAt = new Date(Date.now() + ttl * 1000);
+        state.lockExpiresAt = expiresAt.toISOString();
+        await this.save(state);
+        const contextDir = this.getContextDir(state.agentId, contextId);
+        const lockPath = join(contextDir, 'context.lock');
+        const lockFile = {
+            lockOwnerId,
+            lockedAt: state.lockedAt,
+            expiresAt: state.lockExpiresAt,
+        };
+        await writeFile(lockPath, JSON.stringify(lockFile, null, 2), 'utf-8');
+        return true;
+    }
+    async isLocked(contextId) {
+        const state = await this.load(contextId);
+        if (!state || !state.lockedBy || !state.lockExpiresAt) {
+            return false;
+        }
+        return new Date(state.lockExpiresAt) > new Date();
+    }
+    async update(contextId, updates) {
+        const state = await this.load(contextId);
+        if (!state) {
+            throw new Error(`Context not found: ${contextId}`);
+        }
+        const updatedState = {
+            ...state,
+            ...updates,
+            contextId: state.contextId,
+            agentId: state.agentId,
+            createdAt: state.createdAt,
+            updatedAt: new Date().toISOString(),
+        };
+        await this.save(updatedState);
+    }
+    getContextDir(agentId, contextId) {
+        return join(this.basePath, `agent=${agentId}`, `context=${contextId}`);
+    }
+    async findContextDirs(contextId) {
+        const matches = [];
+        try {
+            const agentDirs = await this.getAllAgentDirs();
+            for (const agentDir of agentDirs) {
+                const contextDir = join(agentDir, `context=${contextId}`);
+                try {
+                    await stat(contextDir);
+                    matches.push(contextDir);
+                }
+                catch {
+                }
+            }
+        }
+        catch {
+        }
+        return matches;
+    }
+    async getAllAgentDirs() {
+        try {
+            const entries = await readdir(this.basePath, { withFileTypes: true });
+            return entries
+                .filter((entry) => entry.isDirectory() && entry.name.startsWith('agent='))
+                .map((entry) => join(this.basePath, entry.name));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return [];
+            }
+            throw error;
+        }
+    }
+}

package/dist/stores/filesystem/filesystem-message-store.d.ts

@@ -0,0 +1,28 @@
+import type { Message } from '../../types/message';
+import type { CompactionOptions, CompactionResult, MessageStore } from '../messages/interfaces';
+export interface FileSystemMessageStoreConfig {
+    basePath?: string;
+    agentId: string;
+}
+export declare class FileSystemMessageStore implements MessageStore {
+    private basePath;
+    private agentId;
+    private messageIndex;
+    constructor(config: FileSystemMessageStoreConfig);
+    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>;
+    private getMessagesDir;
+    private getMessageFilename;
+    private loadMessages;
+    private toMessage;
+    private estimateTokens;
+    private sanitizeName;
+}