@looopy-ai/core 1.0.1

package/dist/stores/artifacts/memory-artifact-store.d.ts

@@ -0,0 +1,52 @@
+import type { ArtifactStore, DatasetSchema, StoredArtifact } from '../../types/artifact';
+export declare class InMemoryArtifactStore implements ArtifactStore {
+    private artifacts;
+    private getContextStore;
+    createFileArtifact(params: {
+        artifactId: string;
+        taskId: string;
+        contextId: string;
+        name?: string;
+        description?: string;
+        mimeType?: string;
+        encoding?: 'utf-8' | 'base64';
+        override?: boolean;
+    }): Promise<string>;
+    appendFileChunk(contextId: string, artifactId: string, chunk: string, options?: {
+        isLastChunk?: boolean;
+        encoding?: 'utf-8' | 'base64';
+    }): Promise<void>;
+    getFileContent(contextId: string, artifactId: string): Promise<string>;
+    createDataArtifact(params: {
+        artifactId: string;
+        taskId: string;
+        contextId: string;
+        name?: string;
+        description?: string;
+        override?: boolean;
+    }): Promise<string>;
+    writeData(contextId: string, artifactId: string, data: Record<string, unknown>): Promise<void>;
+    getDataContent(contextId: string, artifactId: string): Promise<Record<string, unknown>>;
+    createDatasetArtifact(params: {
+        artifactId: string;
+        taskId: string;
+        contextId: string;
+        name?: string;
+        description?: string;
+        schema?: DatasetSchema;
+        override?: boolean;
+    }): Promise<string>;
+    appendDatasetBatch(contextId: string, artifactId: string, rows: Record<string, unknown>[], options?: {
+        isLastBatch?: boolean;
+    }): Promise<void>;
+    getDatasetRows(contextId: string, artifactId: string): Promise<Record<string, unknown>[]>;
+    getArtifact(contextId: string, artifactId: string): Promise<StoredArtifact | null>;
+    listArtifacts(contextId: string, taskId?: string): Promise<string[]>;
+    deleteArtifact(contextId: string, artifactId: string): Promise<void>;
+    queryArtifacts(params: {
+        contextId: string;
+        taskId?: string;
+    }): Promise<string[]>;
+    getArtifactByContext(contextId: string, artifactId: string): Promise<StoredArtifact | null>;
+    getTaskArtifacts(taskId: string): Promise<string[]>;
+}

package/dist/stores/artifacts/memory-artifact-store.js

@@ -0,0 +1,268 @@
+import { randomUUID } from 'node:crypto';
+export class InMemoryArtifactStore {
+    artifacts = new Map();
+    getContextStore(contextId) {
+        let contextStore = this.artifacts.get(contextId);
+        if (!contextStore) {
+            contextStore = new Map();
+            this.artifacts.set(contextId, contextStore);
+        }
+        return contextStore;
+    }
+    async createFileArtifact(params) {
+        const contextStore = this.getContextStore(params.contextId);
+        const existing = contextStore.get(params.artifactId);
+        if (existing && !params.override) {
+            throw new Error(`Artifact already exists: ${params.artifactId} in context ${params.contextId}. ` +
+                `Use override: true to replace it, or use a different artifactId.`);
+        }
+        const now = new Date().toISOString();
+        const createdAt = existing ? existing.createdAt : now;
+        const artifact = {
+            type: 'file',
+            artifactId: params.artifactId,
+            taskId: params.taskId,
+            contextId: params.contextId,
+            name: params.name,
+            description: params.description,
+            mimeType: params.mimeType || 'text/plain',
+            encoding: params.encoding || 'utf-8',
+            chunks: [],
+            totalChunks: 0,
+            totalSize: 0,
+            status: 'building',
+            version: existing && params.override ? existing.version + 1 : 1,
+            operations: [
+                {
+                    operationId: randomUUID(),
+                    type: params.override ? 'reset' : 'create',
+                    timestamp: now,
+                },
+            ],
+            createdAt,
+            updatedAt: now,
+        };
+        contextStore.set(params.artifactId, artifact);
+        return params.artifactId;
+    }
+    async appendFileChunk(contextId, artifactId, chunk, options) {
+        const contextStore = this.getContextStore(contextId);
+        const artifact = contextStore.get(artifactId);
+        if (!artifact) {
+            throw new Error(`Artifact not found: ${artifactId} in context ${contextId}`);
+        }
+        if (artifact.type !== 'file') {
+            throw new Error(`Artifact ${artifactId} is not a file artifact (type: ${artifact.type})`);
+        }
+        const now = new Date().toISOString();
+        if (chunk && chunk.length > 0) {
+            const encoding = options?.encoding || artifact.encoding || 'utf-8';
+            const chunkSize = Buffer.byteLength(chunk, encoding);
+            const artifactChunk = {
+                index: artifact.chunks.length,
+                data: chunk,
+                size: chunkSize,
+                timestamp: now,
+            };
+            artifact.chunks.push(artifactChunk);
+            artifact.totalChunks = artifact.chunks.length;
+            artifact.totalSize += chunkSize;
+            artifact.operations.push({
+                operationId: randomUUID(),
+                type: 'append',
+                timestamp: now,
+                chunkIndex: artifactChunk.index,
+            });
+        }
+        artifact.updatedAt = now;
+        artifact.version += 1;
+        if (options?.isLastChunk) {
+            artifact.status = 'complete';
+            artifact.completedAt = now;
+        }
+    }
+    async getFileContent(contextId, artifactId) {
+        const contextStore = this.getContextStore(contextId);
+        const artifact = contextStore.get(artifactId);
+        if (!artifact) {
+            throw new Error(`Artifact not found: ${artifactId} in context ${contextId}`);
+        }
+        if (artifact.type !== 'file') {
+            throw new Error(`Artifact ${artifactId} is not a file artifact (type: ${artifact.type})`);
+        }
+        return artifact.chunks.map((chunk) => chunk.data).join('');
+    }
+    async createDataArtifact(params) {
+        const contextStore = this.getContextStore(params.contextId);
+        const existing = contextStore.get(params.artifactId);
+        if (existing && !params.override) {
+            throw new Error(`Artifact already exists: ${params.artifactId} in context ${params.contextId}. ` +
+                `Use override: true to replace it, or use a different artifactId.`);
+        }
+        const now = new Date().toISOString();
+        const createdAt = existing ? existing.createdAt : now;
+        const artifact = {
+            type: 'data',
+            artifactId: params.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: randomUUID(),
+                    type: params.override ? 'reset' : 'create',
+                    timestamp: now,
+                },
+            ],
+            createdAt,
+            updatedAt: now,
+        };
+        contextStore.set(params.artifactId, artifact);
+        return params.artifactId;
+    }
+    async writeData(contextId, artifactId, data) {
+        const contextStore = this.getContextStore(contextId);
+        const artifact = contextStore.get(artifactId);
+        if (!artifact) {
+            throw new Error(`Artifact not found: ${artifactId} in context ${contextId}`);
+        }
+        if (artifact.type !== 'data') {
+            throw new Error(`Artifact ${artifactId} is not a data artifact (type: ${artifact.type})`);
+        }
+        const now = new Date().toISOString();
+        artifact.data = data;
+        artifact.updatedAt = now;
+        artifact.version += 1;
+        artifact.status = 'complete';
+        artifact.completedAt = now;
+        artifact.operations.push({
+            operationId: randomUUID(),
+            type: 'replace',
+            timestamp: now,
+        });
+    }
+    async getDataContent(contextId, artifactId) {
+        const contextStore = this.getContextStore(contextId);
+        const artifact = contextStore.get(artifactId);
+        if (!artifact) {
+            throw new Error(`Artifact not found: ${artifactId} in context ${contextId}`);
+        }
+        if (artifact.type !== 'data') {
+            throw new Error(`Artifact ${artifactId} is not a data artifact (type: ${artifact.type})`);
+        }
+        return artifact.data;
+    }
+    async createDatasetArtifact(params) {
+        const contextStore = this.getContextStore(params.contextId);
+        const existing = contextStore.get(params.artifactId);
+        if (existing && !params.override) {
+            throw new Error(`Artifact already exists: ${params.artifactId} in context ${params.contextId}. ` +
+                `Use override: true to replace it, or use a different artifactId.`);
+        }
+        const now = new Date().toISOString();
+        const createdAt = existing ? existing.createdAt : now;
+        const artifact = {
+            type: 'dataset',
+            artifactId: params.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: randomUUID(),
+                    type: params.override ? 'reset' : 'create',
+                    timestamp: now,
+                },
+            ],
+            createdAt,
+            updatedAt: now,
+        };
+        contextStore.set(params.artifactId, artifact);
+        return params.artifactId;
+    }
+    async appendDatasetBatch(contextId, artifactId, rows, options) {
+        const contextStore = this.getContextStore(contextId);
+        const artifact = contextStore.get(artifactId);
+        if (!artifact) {
+            throw new Error(`Artifact not found: ${artifactId} in context ${contextId}`);
+        }
+        if (artifact.type !== 'dataset') {
+            throw new Error(`Artifact ${artifactId} is not a dataset artifact (type: ${artifact.type})`);
+        }
+        const now = new Date().toISOString();
+        if (rows && rows.length > 0) {
+            artifact.rows.push(...rows);
+            artifact.totalChunks += 1;
+            artifact.totalSize = artifact.rows.length;
+            artifact.operations.push({
+                operationId: randomUUID(),
+                type: 'append',
+                timestamp: now,
+                chunkIndex: artifact.totalChunks - 1,
+            });
+        }
+        artifact.updatedAt = now;
+        artifact.version += 1;
+        if (options?.isLastBatch) {
+            artifact.status = 'complete';
+            artifact.completedAt = now;
+        }
+    }
+    async getDatasetRows(contextId, artifactId) {
+        const contextStore = this.getContextStore(contextId);
+        const artifact = contextStore.get(artifactId);
+        if (!artifact) {
+            throw new Error(`Artifact not found: ${artifactId} in context ${contextId}`);
+        }
+        if (artifact.type !== 'dataset') {
+            throw new Error(`Artifact ${artifactId} is not a dataset artifact (type: ${artifact.type})`);
+        }
+        return artifact.rows;
+    }
+    async getArtifact(contextId, artifactId) {
+        const contextStore = this.getContextStore(contextId);
+        return contextStore.get(artifactId) || null;
+    }
+    async listArtifacts(contextId, taskId) {
+        const contextStore = this.getContextStore(contextId);
+        const ids = [];
+        for (const [id, artifact] of contextStore.entries()) {
+            if (!taskId || artifact.taskId === taskId) {
+                ids.push(id);
+            }
+        }
+        return ids;
+    }
+    async deleteArtifact(contextId, artifactId) {
+        const contextStore = this.getContextStore(contextId);
+        contextStore.delete(artifactId);
+    }
+    async queryArtifacts(params) {
+        return this.listArtifacts(params.contextId, params.taskId);
+    }
+    async getArtifactByContext(contextId, artifactId) {
+        return this.getArtifact(contextId, artifactId);
+    }
+    async getTaskArtifacts(taskId) {
+        const ids = [];
+        for (const contextStore of this.artifacts.values()) {
+            for (const [id, artifact] of contextStore.entries()) {
+                if (artifact.taskId === taskId) {
+                    ids.push(id);
+                }
+            }
+        }
+        return ids;
+    }
+}

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

@@ -0,0 +1,18 @@
+import type { AgentState, AgentStore } from '../../types/agent';
+export interface FileSystemAgentStoreConfig {
+    basePath?: string;
+    agentId: string;
+    stateFileName?: string;
+}
+export declare class FileSystemAgentStore implements AgentStore {
+    private readonly basePath;
+    private readonly agentId;
+    private readonly stateFileName;
+    constructor(config: FileSystemAgentStoreConfig);
+    load(contextId: string): Promise<AgentState | null>;
+    save(contextId: string, state: AgentState): Promise<void>;
+    delete(contextId: string): Promise<void>;
+    private getContextDir;
+    private getStateFilePath;
+    private sanitizeName;
+}

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

@@ -0,0 +1,61 @@
+import { readFileSync } from 'node:fs';
+import { mkdir, rm, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+export class FileSystemAgentStore {
+    basePath;
+    agentId;
+    stateFileName;
+    constructor(config) {
+        this.basePath = config.basePath || './_agent_store';
+        this.agentId = config.agentId;
+        this.stateFileName = config.stateFileName || 'agent-state.json';
+    }
+    async load(contextId) {
+        try {
+            const filePath = this.getStateFilePath(contextId);
+            const content = readFileSync(filePath, 'utf-8');
+            const parsed = JSON.parse(content);
+            return {
+                ...parsed,
+                createdAt: new Date(parsed.createdAt),
+                lastActivity: new Date(parsed.lastActivity),
+            };
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return null;
+            }
+            throw error;
+        }
+    }
+    async save(contextId, state) {
+        const contextDir = this.getContextDir(contextId);
+        await mkdir(contextDir, { recursive: true });
+        const filePath = this.getStateFilePath(contextId);
+        const serializable = {
+            ...state,
+            createdAt: state.createdAt.toISOString(),
+            lastActivity: state.lastActivity.toISOString(),
+        };
+        await writeFile(filePath, JSON.stringify(serializable, null, 2), 'utf-8');
+    }
+    async delete(contextId) {
+        const filePath = this.getStateFilePath(contextId);
+        try {
+            await rm(filePath, { force: true });
+        }
+        catch {
+        }
+    }
+    getContextDir(contextId) {
+        const safeAgentId = this.sanitizeName(this.agentId);
+        const safeContextId = this.sanitizeName(contextId);
+        return join(this.basePath, `agent=${safeAgentId}`, `context=${safeContextId}`);
+    }
+    getStateFilePath(contextId) {
+        return join(this.getContextDir(contextId), this.stateFileName);
+    }
+    sanitizeName(name) {
+        return name.replace(/[^a-zA-Z0-9_-]/g, '_');
+    }
+}

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

@@ -0,0 +1,59 @@
+import type { ArtifactStore, DatasetSchema, StoredArtifact } from '../../types/artifact';
+export interface FileSystemArtifactStoreConfig {
+    basePath?: string;
+    agentId: string;
+}
+export declare class FileSystemArtifactStore implements ArtifactStore {
+    private basePath;
+    private agentId;
+    constructor(config: FileSystemArtifactStoreConfig);
+    createFileArtifact(params: {
+        artifactId: string;
+        taskId: string;
+        contextId: string;
+        name?: string;
+        description?: string;
+        mimeType?: string;
+        encoding?: 'utf-8' | 'base64';
+        override?: boolean;
+    }): Promise<string>;
+    appendFileChunk(contextId: string, artifactId: string, chunk: string, options?: {
+        isLastChunk?: boolean;
+    }): Promise<void>;
+    getFileContent(contextId: string, artifactId: string): Promise<string>;
+    createDataArtifact(params: {
+        artifactId: string;
+        taskId: string;
+        contextId: string;
+        name?: string;
+        description?: string;
+        override?: boolean;
+    }): Promise<string>;
+    writeData(contextId: string, artifactId: string, data: Record<string, unknown>): Promise<void>;
+    getDataContent(contextId: string, artifactId: string): Promise<Record<string, unknown>>;
+    createDatasetArtifact(params: {
+        artifactId: string;
+        taskId: string;
+        contextId: string;
+        name?: string;
+        description?: string;
+        schema?: DatasetSchema;
+        override?: boolean;
+    }): Promise<string>;
+    appendDatasetBatch(contextId: string, artifactId: string, rows: Record<string, unknown>[], options?: {
+        isLastBatch?: boolean;
+    }): Promise<void>;
+    getDatasetRows(contextId: string, artifactId: string): Promise<Record<string, unknown>[]>;
+    getArtifact(contextId: string, artifactId: string): Promise<StoredArtifact | null>;
+    deleteArtifact(contextId: string, artifactId: string): Promise<void>;
+    listArtifacts(contextId: string, taskId?: string): Promise<string[]>;
+    queryArtifacts(query: {
+        taskId?: string;
+        contextId?: string;
+        status?: 'building' | 'complete' | 'failed';
+    }): Promise<string[]>;
+    getTaskArtifacts(_taskId: string): Promise<string[]>;
+    private getArtifactDir;
+    private saveMetadata;
+    private loadMetadata;
+}