@props-labs/mesh-os 0.1.23 → 0.2.2

package/dist/core/entities.js

@@ -1,347 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.EntityManager = void 0;
-/**
- * Entity management functionality for MeshOS.
- */
-const taxonomy_1 = require("./taxonomy");
-class EntityManager {
-    constructor(url, headers, createEmbedding) {
-        this.url = url;
-        this.headers = headers;
-        this.createEmbedding = createEmbedding;
-    }
-    /**
-     * Execute a GraphQL query.
-     */
-    async executeQuery(query, variables) {
-        const response = await fetch(this.url, {
-            method: 'POST',
-            headers: this.headers,
-            body: JSON.stringify({
-                query,
-                variables: variables || {}
-            })
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP error! status: ${response.status}`);
-        }
-        const result = await response.json();
-        if (result.errors) {
-            throw new Error(result.errors[0].message);
-        }
-        return result.data;
-    }
-    /**
-     * Add a new entity.
-     */
-    async add(entity) {
-        // Validate entity data
-        const validatedData = taxonomy_1.entitySchema.omit({ id: true, createdAt: true, updatedAt: true }).parse(entity);
-        // Create embedding from name and description
-        const embeddingText = `${validatedData.name} ${validatedData.description || ''}`.trim();
-        const embedding = await this.createEmbedding(embeddingText);
-        const embeddingStr = `[${embedding.join(',')}]`;
-        const query = `
-      mutation AddEntity($entity: entities_insert_input!) {
-        insert_entities_one(object: $entity) {
-          id
-          ref_id
-          type
-          name
-          description
-          metadata
-          status
-          created_at
-          updated_at
-        }
-      }
-    `;
-        const result = await this.executeQuery(query, {
-            entity: {
-                ref_id: validatedData.refId,
-                type: validatedData.type,
-                name: validatedData.name,
-                description: validatedData.description,
-                metadata: validatedData.metadata,
-                status: validatedData.status,
-                embedding: embeddingStr
-            }
-        });
-        // Convert snake_case to camelCase
-        const { ref_id, created_at, updated_at, ...rest } = result.insert_entities_one;
-        return {
-            ...rest,
-            refId: ref_id,
-            createdAt: created_at,
-            updatedAt: updated_at,
-        };
-    }
-    /**
-     * Get an entity by ID.
-     */
-    async get(id) {
-        const query = `
-      query GetEntity($id: uuid!) {
-        entities_by_pk(id: $id) {
-          id
-          ref_id
-          type
-          name
-          description
-          metadata
-          status
-          created_at
-          updated_at
-        }
-      }
-    `;
-        const result = await this.executeQuery(query, { id });
-        if (!result.entities_by_pk) {
-            return null;
-        }
-        // Convert snake_case to camelCase
-        const { ref_id, created_at, updated_at, ...rest } = result.entities_by_pk;
-        return {
-            ...rest,
-            refId: ref_id,
-            createdAt: created_at,
-            updatedAt: updated_at,
-        };
-    }
-    /**
-     * Get an entity by reference ID.
-     */
-    async getByRefId(refId) {
-        const query = `
-      query GetEntityByRefId($refId: String!) {
-        entities(where: {ref_id: {_eq: $refId}}, limit: 1) {
-          id
-          ref_id
-          type
-          name
-          description
-          metadata
-          status
-          created_at
-          updated_at
-        }
-      }
-    `;
-        const result = await this.executeQuery(query, { refId });
-        if (!result.entities[0]) {
-            return null;
-        }
-        // Convert snake_case to camelCase
-        const { ref_id, created_at, updated_at, ...rest } = result.entities[0];
-        return {
-            ...rest,
-            refId: ref_id,
-            createdAt: created_at,
-            updatedAt: updated_at,
-        };
-    }
-    /**
-     * Update an entity.
-     */
-    async update(id, updates) {
-        // If name or description is updated, update embedding
-        let embedding;
-        if (updates.name || updates.description) {
-            const entity = await this.get(id);
-            if (!entity) {
-                throw new Error(`Entity ${id} not found`);
-            }
-            const embeddingText = `${updates.name || entity.name} ${updates.description || entity.description || ''}`.trim();
-            embedding = await this.createEmbedding(embeddingText);
-        }
-        const query = `
-      mutation UpdateEntity($id: uuid!, $updates: entities_set_input!) {
-        update_entities_by_pk(pk_columns: {id: $id}, _set: $updates) {
-          id
-          ref_id
-          type
-          name
-          description
-          metadata
-          status
-          created_at
-          updated_at
-        }
-      }
-    `;
-        const updateData = {
-            ref_id: updates.refId,
-            type: updates.type,
-            name: updates.name,
-            description: updates.description,
-            metadata: updates.metadata,
-            status: updates.status,
-        };
-        if (embedding) {
-            updateData.embedding = `[${embedding.join(',')}]`;
-        }
-        // Remove undefined values
-        Object.keys(updateData).forEach(key => updateData[key] === undefined && delete updateData[key]);
-        const result = await this.executeQuery(query, {
-            id,
-            updates: updateData
-        });
-        // Convert snake_case to camelCase
-        const { ref_id, created_at, updated_at, ...rest } = result.update_entities_by_pk;
-        return {
-            ...rest,
-            refId: ref_id,
-            createdAt: created_at,
-            updatedAt: updated_at,
-        };
-    }
-    /**
-     * Delete an entity.
-     */
-    async delete(id) {
-        const query = `
-      mutation DeleteEntity($id: uuid!) {
-        delete_entities_by_pk(id: $id) {
-          id
-        }
-      }
-    `;
-        const result = await this.executeQuery(query, { id });
-        return result.delete_entities_by_pk !== null;
-    }
-    /**
-     * Search entities by semantic similarity.
-     */
-    async search(options) {
-        const { query, threshold = 0.7, limit = 10, type, status } = options;
-        // Create embedding for search query
-        const embedding = await this.createEmbedding(query);
-        const embeddingStr = `[${embedding.join(',')}]`;
-        const searchQuery = `
-      query SearchEntities(
-        $embedding: vector!,
-        $threshold: float8!,
-        $limit: Int!,
-        $type: String,
-        $status: String
-      ) {
-        entities(
-          where: {
-            _and: [
-              {type: {_eq: $type}},
-              {status: {_eq: $status}}
-            ]
-          },
-          order_by: {embedding: {_cosine_distance: $embedding}},
-          limit: $limit
-        ) {
-          id
-          ref_id
-          type
-          name
-          description
-          metadata
-          status
-          created_at
-          updated_at
-          similarity: _cosine_similarity_embedding_with($embedding)
-        }
-      }
-    `;
-        const result = await this.executeQuery(searchQuery, {
-            embedding: embeddingStr,
-            threshold,
-            limit,
-            type,
-            status
-        });
-        return result.entities.map(entity => {
-            const { ref_id, created_at, updated_at, ...rest } = entity;
-            return {
-                ...rest,
-                refId: ref_id,
-                createdAt: created_at,
-                updatedAt: updated_at,
-            };
-        }).filter(entity => (entity.similarity || 0) >= threshold);
-    }
-    /**
-     * Link an entity to a memory.
-     */
-    async linkMemory(entityId, memoryId, relationship, confidence) {
-        const query = `
-      mutation LinkEntityMemory($link: entity_memory_links_insert_input!) {
-        insert_entity_memory_links_one(object: $link) {
-          id
-          entity_id
-          memory_id
-          relationship
-          confidence
-          created_at
-        }
-      }
-    `;
-        const result = await this.executeQuery(query, {
-            link: {
-                entity_id: entityId,
-                memory_id: memoryId,
-                relationship,
-                confidence: confidence || 1.0
-            }
-        });
-        // Convert snake_case to camelCase
-        const { entity_id, memory_id, created_at, ...rest } = result.insert_entity_memory_links_one;
-        return {
-            ...rest,
-            entityId: entity_id,
-            memoryId: memory_id,
-            createdAt: created_at,
-        };
-    }
-    /**
-     * Get all memories linked to an entity.
-     */
-    async getLinkedMemories(entityId, relationship) {
-        const query = `
-      query GetLinkedMemories($entityId: uuid!, $relationship: String) {
-        entity_memory_links(
-          where: {
-            entity_id: {_eq: $entityId},
-            relationship: {_eq: $relationship}
-          }
-        ) {
-          memory {
-            id
-            agent_id
-            content
-            metadata
-            created_at
-            updated_at
-            expires_at
-          }
-          relationship
-          confidence
-        }
-      }
-    `;
-        const result = await this.executeQuery(query, {
-            entityId,
-            relationship
-        });
-        return result.entity_memory_links.map(link => {
-            const { memory, relationship, confidence } = link;
-            const { agent_id, created_at, updated_at, expires_at, ...rest } = memory;
-            return {
-                ...rest,
-                agentId: agent_id,
-                createdAt: created_at,
-                updatedAt: updated_at,
-                expiresAt: expires_at,
-                relationship,
-                confidence
-            };
-        });
-    }
-}
-exports.EntityManager = EntityManager;

package/src/templates/hasura/metadata/config.yaml

@@ -1 +0,0 @@
- 

package/src/templates/hasura/metadata/databases/default/tables/public_agents.yaml

@@ -1,14 +0,0 @@
-table:
-  name: agents
-  schema: public
-configuration:
-  custom_root_fields: {}
-  custom_name: agents
-array_relationships:
-  - name: memories
-    using:
-      foreign_key_constraint_on:
-        column: agent_id
-        table:
-          name: memories
-          schema: public 

package/src/templates/hasura/metadata/databases/default/tables/public_memories.yaml

@@ -1,23 +0,0 @@
-table:
-  name: memories
-  schema: public
-configuration:
-  custom_root_fields: {}
-  custom_name: memories
-object_relationships:
-  - name: agent
-    using:
-      foreign_key_constraint_on: agent_id
-computed_fields:
-  - name: similarity_score
-    definition:
-      function:
-        name: search_memories
-        schema: public
-        arguments:
-          query_embedding: $query_embedding
-          match_threshold: $match_threshold
-          match_count: $match_count
-          filter_agent_id: $filter_agent_id
-          metadata_filter: $metadata_filter
-    comment: Computes similarity score for vector search 

package/src/templates/hasura/metadata/databases/default/tables/public_memory_edges.yaml

@@ -1,57 +0,0 @@
-table:
-  name: memory_edges
-  schema: public
-is_enum: false
-configuration:
-  column_config: {}
-  custom_column_names: {}
-  custom_name: memory_edges
-  custom_root_fields: {}
-
-array_relationships: []
-computed_fields: []
-delete_permissions:
-  - role: admin
-    permission:
-      filter: {}
-
-event_triggers: []
-insert_permissions:
-  - role: admin
-    permission:
-      check: {}
-      columns:
-        - id
-        - source_memory
-        - target_memory
-        - relationship
-        - weight
-        - created_at
-
-object_relationships:
-  - name: source
-    using:
-      foreign_key_constraint_on: source_memory
-  - name: target
-    using:
-      foreign_key_constraint_on: target_memory
-
-select_permissions:
-  - role: admin
-    permission:
-      columns:
-        - id
-        - source_memory
-        - target_memory
-        - relationship
-        - weight
-        - created_at
-      filter: {}
-
-update_permissions:
-  - role: admin
-    permission:
-      columns:
-        - weight
-      filter: {}
-      check: {} 

package/src/templates/hasura/metadata/databases/default/tables/track_tables.yaml

@@ -1,14 +0,0 @@
-- table:
-    schema: public
-    name: agents
-  is_enum: false
-
-- table:
-    schema: public
-    name: memories
-  is_enum: false
-
-- table:
-    schema: public
-    name: memory_edges
-  is_enum: false 

package/src/templates/hasura/metadata/metadata.json

@@ -1,80 +0,0 @@
-{
-  "version": 3,
-  "sources": [
-    {
-      "name": "default",
-      "kind": "postgres",
-      "tables": [
-        {
-          "table": {
-            "schema": "public",
-            "name": "agents"
-          },
-          "array_relationships": [
-            {
-              "name": "memories",
-              "using": {
-                "foreign_key_constraint_on": {
-                  "column": "agent_id",
-                  "table": {
-                    "schema": "public",
-                    "name": "memories"
-                  }
-                }
-              }
-            }
-          ]
-        },
-        {
-          "table": {
-            "schema": "public",
-            "name": "memories"
-          },
-          "object_relationships": [
-            {
-              "name": "agent",
-              "using": {
-                "foreign_key_constraint_on": "agent_id"
-              }
-            }
-          ],
-          "computed_fields": [
-            {
-              "name": "similarity_score",
-              "definition": {
-                "function": {
-                  "schema": "public",
-                  "name": "search_memories"
-                }
-              },
-              "comment": "Computes similarity score for vector search"
-            }
-          ]
-        }
-      ],
-      "functions": [
-        {
-          "function": {
-            "schema": "public",
-            "name": "search_memories"
-          }
-        }
-      ],
-      "configuration": {
-        "connection_info": {
-          "use_prepared_statements": true,
-          "database_url": {
-            "from_env": "HASURA_GRAPHQL_DATABASE_URL"
-          },
-          "isolation_level": "read-committed",
-          "pool_settings": {
-            "connection_lifetime": 600,
-            "retries": 1,
-            "idle_timeout": 180,
-            "max_connections": 50
-          }
-        }
-      }
-    }
-  ]
-} 

package/src/templates/hasura/migrations/default/2_metadata_filtering/down.sql

@@ -1,4 +0,0 @@
--- Drop the updated search_memories function with metadata filtering
-DROP FUNCTION public.search_memories(vector(1536), float8, integer, uuid, jsonb);
-
--- Note: The original search_memories function from 1_init will be restored when that migration is reapplied 

package/src/templates/hasura/migrations/default/2_metadata_filtering/up.sql

@@ -1,44 +0,0 @@
--- Drop the existing search_memories function
-DROP FUNCTION IF EXISTS public.search_memories;
-
--- Create the updated search_memories function with metadata filtering
-CREATE OR REPLACE FUNCTION public.search_memories(
-    query_embedding vector(1536),
-    match_threshold float8,
-    match_count integer,
-    filter_agent_id uuid DEFAULT NULL,
-    metadata_filter jsonb DEFAULT NULL
-)
-RETURNS SETOF public.memories_with_similarity
-LANGUAGE sql
-STABLE
-AS $$
-    WITH normalized_query AS (
-        SELECT l2_normalize(query_embedding) AS normalized_vector
-    )
-    SELECT 
-        m.id,
-        m.agent_id,
-        m.content,
-        m.metadata,
-        m.embedding,
-        m.created_at,
-        m.updated_at,
-        -(m.embedding <#> (SELECT normalized_vector FROM normalized_query)) as similarity
-    FROM memories m
-    WHERE
-        CASE 
-            WHEN filter_agent_id IS NOT NULL THEN m.agent_id = filter_agent_id
-            ELSE TRUE
-        END
-        AND CASE
-            WHEN metadata_filter IS NOT NULL THEN m.metadata @> metadata_filter
-            ELSE TRUE
-        END
-        AND -(m.embedding <#> (SELECT normalized_vector FROM normalized_query)) >= match_threshold
-    ORDER BY -(m.embedding <#> (SELECT normalized_vector FROM normalized_query)) DESC
-    LIMIT match_count;
-$$;
-
--- Track the function in Hasura
-COMMENT ON FUNCTION public.search_memories IS E'@graphql({"type": "Query"})'; 

package/src/templates/hasura/migrations/default/3_memory_expiry/down.sql

@@ -1,55 +0,0 @@
--- Drop the updated search_memories function
-DROP FUNCTION IF EXISTS public.search_memories(vector(1536), float8, integer, uuid, jsonb, jsonb, jsonb);
-
--- Remove expires_at column
-ALTER TABLE public.memories DROP COLUMN expires_at;
-
--- Drop and recreate the view without expires_at
-DROP VIEW IF EXISTS public.memories_with_similarity;
-CREATE OR REPLACE VIEW public.memories_with_similarity AS
-SELECT 
-    m.*,
-    0::float8 as similarity
-FROM memories m;
-
--- Restore the previous version of search_memories from 2_metadata_filtering
-CREATE OR REPLACE FUNCTION public.search_memories(
-    query_embedding vector(1536),
-    match_threshold float8,
-    match_count integer,
-    filter_agent_id uuid DEFAULT NULL,
-    metadata_filter jsonb DEFAULT NULL
-)
-RETURNS SETOF public.memories_with_similarity
-LANGUAGE sql
-STABLE
-AS $$
-    WITH normalized_query AS (
-        SELECT l2_normalize(query_embedding) AS normalized_vector
-    )
-    SELECT 
-        m.id,
-        m.agent_id,
-        m.content,
-        m.metadata,
-        m.embedding,
-        m.created_at,
-        m.updated_at,
-        -(m.embedding <#> (SELECT normalized_vector FROM normalized_query)) as similarity
-    FROM memories m
-    WHERE
-        CASE 
-            WHEN filter_agent_id IS NOT NULL THEN m.agent_id = filter_agent_id
-            ELSE TRUE
-        END
-        AND CASE
-            WHEN metadata_filter IS NOT NULL THEN m.metadata @> metadata_filter
-            ELSE TRUE
-        END
-        AND -(m.embedding <#> (SELECT normalized_vector FROM normalized_query)) >= match_threshold
-    ORDER BY -(m.embedding <#> (SELECT normalized_vector FROM normalized_query)) DESC
-    LIMIT match_count;
-$$;
-
--- Track the function in Hasura
-COMMENT ON FUNCTION public.search_memories IS E'@graphql({"type": "Query"})';