@props-labs/mesh-os 0.2.2 → 0.2.3

package/dist/core/__fixtures__/mock_responses.d.ts

@@ -171,6 +171,23 @@ export declare const MEMORY_MOCKS: {
             })[];
         };
     };
+    listMemories: {
+        data: {
+            memories: {
+                id: string;
+                type: string;
+                status: string;
+                content: string;
+                metadata: {
+                    source: string;
+                    tags: string[];
+                };
+                created_at: string;
+                updated_at: string;
+                agent_id: "d7f3668d-5ebf-4f95-9b5c-07301f5d4c62";
+            }[];
+        };
+    };
 };
 export declare const WORKFLOW_MOCKS: {
     listSchemas: {

package/dist/core/__fixtures__/mock_responses.js

@@ -151,6 +151,51 @@ exports.MEMORY_MOCKS = {
                 }
             ]
         }
+    },
+    listMemories: {
+        data: {
+            memories: [
+                {
+                    id: exports.SAMPLE_IDS.MEMORY,
+                    type: 'text_document',
+                    status: 'active',
+                    content: 'Test memory 1',
+                    metadata: {
+                        source: 'test',
+                        tags: ['test', 'first']
+                    },
+                    created_at: '2025-02-18T00:00:00Z',
+                    updated_at: '2025-02-18T00:00:00Z',
+                    agent_id: exports.SAMPLE_IDS.AGENT
+                },
+                {
+                    id: '22222222-2222-2222-2222-222222222222',
+                    type: 'code_snippet',
+                    status: 'active',
+                    content: 'Test memory 2',
+                    metadata: {
+                        source: 'test',
+                        tags: ['test', 'second']
+                    },
+                    created_at: '2025-02-18T00:00:01Z',
+                    updated_at: '2025-02-18T00:00:01Z',
+                    agent_id: exports.SAMPLE_IDS.AGENT
+                },
+                {
+                    id: '33333333-3333-3333-3333-333333333333',
+                    type: 'text_document',
+                    status: 'archived',
+                    content: 'Test memory 3',
+                    metadata: {
+                        source: 'test',
+                        tags: ['test', 'third']
+                    },
+                    created_at: '2025-02-18T00:00:02Z',
+                    updated_at: '2025-02-18T00:00:02Z',
+                    agent_id: exports.SAMPLE_IDS.AGENT
+                }
+            ]
+        }
     }
 };
 // Workflow mock responses
@@ -343,6 +388,9 @@ const createMockFetch = (mocks) => {
         else if (query.includes('GetLastWorkflowResult')) {
             mockResponse = mocks.getLastResult;
         }
+        else if (query.includes('ListMemories')) {
+            mockResponse = mocks.listMemories;
+        }
         if (!mockResponse) {
             throw new Error(`No mock response found for query: ${query}`);
         }

package/dist/core/memories.d.ts

@@ -76,6 +76,17 @@ export interface SearchMemoryOptions {
     metadataFilter?: Record<string, any>;
     createdAtFilter?: Record<string, any>;
 }
+export interface ListMemoriesOptions {
+    type?: string;
+    status?: 'active' | 'archived' | 'deleted';
+    limit?: number;
+    offset?: number;
+    agentId?: string;
+    orderBy?: Array<{
+        field: string;
+        direction: 'asc' | 'desc';
+    }>;
+}
 export interface UpdateMemoryInput {
     id: string;
     content?: string;
@@ -135,4 +146,8 @@ export declare class MemoryManager {
      * List all available type schemas
      */
     listSchemas(): Promise<TypeSchema[]>;
+    /**
+     * List memories with optional filtering and pagination
+     */
+    listMemories(options?: ListMemoriesOptions): Promise<Memory[]>;
 }

package/dist/core/memories.js

@@ -413,5 +413,54 @@ class MemoryManager {
         const result = await this.executeQuery(query, {});
         return result.type_schemas.map(schema => typeSchemaSchema.parse(schema));
     }
+    /**
+     * List memories with optional filtering and pagination
+     */
+    async listMemories(options = {}) {
+        const { type, status, limit = 10, offset = 0, agentId, orderBy = [{ field: 'created_at', direction: 'desc' }] } = options;
+        // Build where clause
+        const where = {};
+        if (type)
+            where.type = { _eq: type };
+        if (status)
+            where.status = { _eq: status };
+        if (agentId)
+            where.agent_id = { _eq: agentId };
+        // Convert orderBy to Hasura format
+        const orderByClause = orderBy.map(({ field, direction }) => ({
+            [field]: direction
+        }));
+        const query = `
+      query ListMemories(
+        $where: memories_bool_exp!,
+        $limit: Int!,
+        $offset: Int!,
+        $orderBy: [memories_order_by!]!
+      ) {
+        memories(
+          where: $where,
+          limit: $limit,
+          offset: $offset,
+          order_by: $orderBy
+        ) {
+          id
+          type
+          status
+          metadata
+          content
+          created_at
+          updated_at
+          agent_id
+        }
+      }
+    `;
+        const result = await this.executeQuery(query, {
+            where,
+            limit,
+            offset,
+            orderBy: orderByClause
+        });
+        return result.memories.map(memory => memorySchema.parse(memory));
+    }
 }
 exports.MemoryManager = MemoryManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@props-labs/mesh-os",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "MeshOS - A memory system for AI agents",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",