@elevasis/core 0.16.0 → 0.18.0

package/src/knowledge/published.ts

@@ -0,0 +1,5 @@
+export { byFeature, byKind, byOwner, governs, governedBy, parsePath } from './queries'
+export type { KnowledgeMount, ParsedKnowledgePath } from './queries'
+
+export { formatText, formatJson, formatIdsOnly } from './format'
+export type { KnowledgeJsonEnvelope } from './format'

package/src/platform/registry/__tests__/resource-registry.list-executable.test.ts

@@ -1,393 +0,0 @@
-/**
- * Test: ResourceRegistry.listExecutable()
- * Verifies registry serialization includes interface config
- * and listExecutable() filters resources with interfaces
- */
-
-import { describe, it, expect } from 'vitest'
-import { z } from 'zod'
-import { ResourceRegistry } from '../resource-registry'
-import type { WorkflowDefinition } from '../../../execution/engine/workflow/types'
-import type { AgentDefinition } from '../../../execution/engine/agent/core/types'
-import type { OrganizationRegistry } from '../resource-registry'
-
-describe('ResourceRegistry - listExecutable()', () => {
-  it('should return empty array when organization has no resources', () => {
-    const registry: OrganizationRegistry = {
-      'test-org': {}
-    }
-
-    const resourceRegistry = new ResourceRegistry(registry)
-    const executable = resourceRegistry.listExecutable('test-org')
-
-    expect(executable).toEqual([])
-  })
-
-  it('should return empty array when no resources have interfaces', () => {
-    const workflowWithoutInterface: WorkflowDefinition = {
-      config: {
-        resourceId: 'workflow-no-interface',
-        name: 'Workflow Without Interface',
-        description: 'Test workflow',
-        version: '1.0.0',
-        type: 'workflow',
-        status: 'prod'
-      },
-      contract: {
-        inputSchema: z.object({}),
-        outputSchema: z.object({})
-      },
-      steps: {},
-      entryPoint: 'start'
-      // No interface field
-    }
-
-    const registry: OrganizationRegistry = {
-      'test-org': {
-        workflows: [workflowWithoutInterface]
-      }
-    }
-
-    const resourceRegistry = new ResourceRegistry(registry)
-    const executable = resourceRegistry.listExecutable('test-org')
-
-    expect(executable).toEqual([])
-  })
-
-  it('should return workflow with interface', () => {
-    const workflowWithInterface: WorkflowDefinition = {
-      config: {
-        resourceId: 'workflow-with-interface',
-        name: 'Executable Workflow',
-        description: 'Test workflow with UI',
-        version: '1.0.0',
-        type: 'workflow',
-        status: 'prod'
-      },
-      contract: {
-        inputSchema: z.object({ input: z.string() }),
-        outputSchema: z.object({ output: z.string() })
-      },
-      steps: {},
-      entryPoint: 'start',
-      interface: {
-        form: {
-          title: 'Run Workflow',
-          description: 'Execute this workflow',
-          fields: [
-            {
-              name: 'input',
-              label: 'Input Text',
-              type: 'text',
-              required: true
-            }
-          ]
-        }
-      }
-    }
-
-    const registry: OrganizationRegistry = {
-      'test-org': {
-        workflows: [workflowWithInterface]
-      }
-    }
-
-    const resourceRegistry = new ResourceRegistry(registry)
-    const executable = resourceRegistry.listExecutable('test-org')
-
-    expect(executable).toHaveLength(1)
-    expect(executable[0]).toMatchObject({
-      resourceId: 'workflow-with-interface',
-      resourceName: 'Executable Workflow',
-      resourceType: 'workflow',
-      description: 'Test workflow with UI'
-    })
-    expect(executable[0].interface).toBeDefined()
-    expect(executable[0].interface.form.title).toBe('Run Workflow')
-    expect(executable[0].interface.form.fields).toHaveLength(1)
-  })
-
-  it('should return agent with interface', () => {
-    const agentWithInterface: AgentDefinition = {
-      config: {
-        resourceId: 'agent-with-interface',
-        name: 'Executable Agent',
-        description: 'Test agent with UI',
-        version: '1.0.0',
-        type: 'agent',
-        status: 'prod',
-        systemPrompt: 'You are a test agent'
-      },
-      contract: {
-        inputSchema: z.object({ task: z.string() }),
-        outputSchema: z.object({ result: z.string() })
-      },
-      tools: [],
-      modelConfig: {
-        provider: 'openai',
-        model: 'gpt-5.4-mini',
-        apiKey: 'sk-test123',
-        temperature: 1,
-        maxOutputTokens: 4000
-      },
-      interface: {
-        form: {
-          title: 'Run Agent',
-          description: 'Execute this agent',
-          fields: [
-            {
-              name: 'task',
-              label: 'Task Description',
-              type: 'textarea',
-              required: true
-            }
-          ]
-        }
-      }
-    }
-
-    const registry: OrganizationRegistry = {
-      'test-org': {
-        agents: [agentWithInterface]
-      }
-    }
-
-    const resourceRegistry = new ResourceRegistry(registry)
-    const executable = resourceRegistry.listExecutable('test-org')
-
-    expect(executable).toHaveLength(1)
-    expect(executable[0]).toMatchObject({
-      resourceId: 'agent-with-interface',
-      resourceName: 'Executable Agent',
-      resourceType: 'agent',
-      description: 'Test agent with UI'
-    })
-    expect(executable[0].interface).toBeDefined()
-    expect(executable[0].interface.form.title).toBe('Run Agent')
-  })
-
-  it('should filter by environment (prod only)', () => {
-    const devWorkflow: WorkflowDefinition = {
-      config: {
-        resourceId: 'dev-workflow',
-        name: 'Dev Workflow',
-        description: 'Development workflow',
-        version: '1.0.0',
-        type: 'workflow',
-        status: 'dev'
-      },
-      contract: {
-        inputSchema: z.object({ test: z.string().optional() }),
-        outputSchema: z.object({})
-      },
-      steps: {},
-      entryPoint: 'start',
-      interface: {
-        form: {
-          fields: [{ name: 'test', label: 'Test', type: 'text' }]
-        }
-      }
-    }
-
-    const prodWorkflow: WorkflowDefinition = {
-      config: {
-        resourceId: 'prod-workflow',
-        name: 'Prod Workflow',
-        description: 'Production workflow',
-        version: '1.0.0',
-        type: 'workflow',
-        status: 'prod'
-      },
-      contract: {
-        inputSchema: z.object({ test: z.string().optional() }),
-        outputSchema: z.object({})
-      },
-      steps: {},
-      entryPoint: 'start',
-      interface: {
-        form: {
-          fields: [{ name: 'test', label: 'Test', type: 'text' }]
-        }
-      }
-    }
-
-    const registry: OrganizationRegistry = {
-      'test-org': {
-        workflows: [devWorkflow, prodWorkflow]
-      }
-    }
-
-    const resourceRegistry = new ResourceRegistry(registry)
-    const executable = resourceRegistry.listExecutable('test-org', 'prod')
-
-    expect(executable).toHaveLength(1)
-    expect(executable[0].resourceId).toBe('prod-workflow')
-  })
-
-  it('should return both workflows and agents with interfaces', () => {
-    const workflow: WorkflowDefinition = {
-      config: {
-        resourceId: 'workflow-1',
-        name: 'Workflow 1',
-        description: 'Test',
-        version: '1.0.0',
-        type: 'workflow',
-        status: 'prod'
-      },
-      contract: {
-        inputSchema: z.object({ test: z.string().optional() }),
-        outputSchema: z.object({})
-      },
-      steps: {},
-      entryPoint: 'start',
-      interface: {
-        form: {
-          fields: [{ name: 'test', label: 'Test', type: 'text' }]
-        }
-      }
-    }
-
-    const agent: AgentDefinition = {
-      config: {
-        resourceId: 'agent-1',
-        name: 'Agent 1',
-        description: 'Test',
-        version: '1.0.0',
-        type: 'agent',
-        status: 'prod',
-        systemPrompt: 'Test'
-      },
-      contract: {
-        inputSchema: z.object({ test: z.string().optional() }),
-        outputSchema: z.object({})
-      },
-      tools: [],
-      modelConfig: {
-        provider: 'openai',
-        model: 'gpt-5.4-mini',
-        apiKey: 'sk-test',
-        temperature: 1,
-        maxOutputTokens: 4000
-      },
-      interface: {
-        form: {
-          fields: [{ name: 'test', label: 'Test', type: 'text' }]
-        }
-      }
-    }
-
-    const registry: OrganizationRegistry = {
-      'test-org': {
-        workflows: [workflow],
-        agents: [agent]
-      }
-    }
-
-    const resourceRegistry = new ResourceRegistry(registry)
-    const executable = resourceRegistry.listExecutable('test-org')
-
-    expect(executable).toHaveLength(2)
-    expect(executable.map((r) => r.resourceType)).toContain('workflow')
-    expect(executable.map((r) => r.resourceType)).toContain('agent')
-  })
-
-  it('should serialize interface fields correctly', () => {
-    const workflow: WorkflowDefinition = {
-      config: {
-        resourceId: 'workflow-full-interface',
-        name: 'Full Interface Workflow',
-        description: 'Test',
-        version: '1.0.0',
-        type: 'workflow',
-        status: 'prod'
-      },
-      contract: {
-        inputSchema: z.object({
-          inputText: z.string(),
-          inputSelect: z.string().optional()
-        }),
-        outputSchema: z.object({})
-      },
-      steps: {},
-      entryPoint: 'start',
-      interface: {
-        form: {
-          title: 'Test Form',
-          description: 'Test Description',
-          fields: [
-            {
-              name: 'text-field',
-              label: 'Text Field',
-              type: 'text',
-              required: true,
-              placeholder: 'Enter text'
-            },
-            {
-              name: 'select-field',
-              label: 'Select Field',
-              type: 'select',
-              options: [
-                { label: 'Option 1', value: 'opt1' },
-                { label: 'Option 2', value: 'opt2' }
-              ]
-            }
-          ],
-          fieldMappings: {
-            'text-field': 'inputText',
-            'select-field': 'inputSelect'
-          },
-          submitButton: {
-            label: 'Execute',
-            loadingLabel: 'Executing...',
-            confirmMessage: 'Are you sure?'
-          }
-        },
-        schedule: {
-          enabled: true,
-          defaultSchedule: '0 0 * * *',
-          allowedPatterns: ['0 0 * * *', '0 12 * * *']
-        },
-        webhook: {
-          enabled: true,
-          payloadSchema: { type: 'object' }
-        }
-      }
-    }
-
-    const registry: OrganizationRegistry = {
-      'test-org': {
-        workflows: [workflow]
-      }
-    }
-
-    const resourceRegistry = new ResourceRegistry(registry)
-    const executable = resourceRegistry.listExecutable('test-org')
-
-    expect(executable).toHaveLength(1)
-
-    const serializedInterface = executable[0].interface
-
-    // Verify form serialization
-    expect(serializedInterface.form.title).toBe('Test Form')
-    expect(serializedInterface.form.description).toBe('Test Description')
-    expect(serializedInterface.form.fields).toHaveLength(2)
-    expect(serializedInterface.form.fieldMappings).toEqual({
-      'text-field': 'inputText',
-      'select-field': 'inputSelect'
-    })
-    expect(serializedInterface.form.submitButton).toEqual({
-      label: 'Execute',
-      loadingLabel: 'Executing...',
-      confirmMessage: 'Are you sure?'
-    })
-
-    // Verify schedule serialization
-    expect(serializedInterface.schedule).toBeDefined()
-    expect(serializedInterface.schedule!.enabled).toBe(true)
-    expect(serializedInterface.schedule!.defaultSchedule).toBe('0 0 * * *')
-
-    // Verify webhook serialization
-    expect(serializedInterface.webhook).toBeDefined()
-    expect(serializedInterface.webhook!.enabled).toBe(true)
-  })
-})