@elevasis/core 0.22.0 → 0.24.0

package/src/test-utils/test-utils.test.ts

@@ -1,49 +1,44 @@
-import { describe, expect, it } from 'vitest'
-import { BaseProjectSchema, BaseTaskSchema } from '../business/base-entities'
-import { DEFAULT_ORGANIZATION_MODEL } from '../organization-model'
-import {
-  makeInitializationState,
-  makeOrganizationModel,
-  makeProject,
-  makeTask,
-  makeUserProfile,
-  TEST_ORGS,
-  TEST_USERS
-} from './published'
-
-describe('published test-utils factories', () => {
-  it('creates schema-validated base entities with overrides', () => {
-    const project = makeProject({ name: 'Custom Project', metadata: { source: 'test' } })
-    const task = makeTask({ projectId: project.id, status: 'done' })
-
-    expect(BaseProjectSchema.parse(project)).toMatchObject({
-      name: 'Custom Project',
-      metadata: { source: 'test' }
-    })
-    expect(BaseTaskSchema.parse(task)).toMatchObject({
-      projectId: project.id,
-      status: 'done'
-    })
-  })
-
-  it('creates organization model and initialization fixtures', () => {
-    const model = makeOrganizationModel({
-      branding: { organizationName: 'Test Brand' },
-      features: DEFAULT_ORGANIZATION_MODEL.features.map((feature) =>
-        feature.id === 'seo' ? { ...feature, enabled: true } : feature
-      )
-    })
-    const profile = makeUserProfile({ id: TEST_USERS.admin.id, email: TEST_USERS.admin.email })
-    const state = makeInitializationState({ profile, organizationReady: false, allReady: false })
-
-    expect(model.branding.organizationName).toBe('Test Brand')
-    expect(model.features.find((feature) => feature.id === 'seo')?.enabled).toBe(true)
-    expect(state.profile?.email).toBe(TEST_USERS.admin.email)
-    expect(state.organizationReady).toBe(false)
-  })
-
-  it('promotes existing fixture surface through the public barrel', () => {
-    expect(TEST_USERS.admin.email).toBe('admin@test.com')
-    expect(TEST_ORGS.acme.name).toBe('Acme Corp')
-  })
-})
+import { describe, expect, it } from 'vitest'
+import { BaseProjectSchema, BaseTaskSchema } from '../business/base-entities'
+import {
+  makeInitializationState,
+  makeOrganizationModel,
+  makeProject,
+  makeTask,
+  makeUserProfile,
+  TEST_ORGS,
+  TEST_USERS
+} from './published'
+
+describe('published test-utils factories', () => {
+  it('creates schema-validated base entities with overrides', () => {
+    const project = makeProject({ name: 'Custom Project', metadata: { source: 'test' } })
+    const task = makeTask({ projectId: project.id, status: 'done' })
+
+    expect(BaseProjectSchema.parse(project)).toMatchObject({
+      name: 'Custom Project',
+      metadata: { source: 'test' }
+    })
+    expect(BaseTaskSchema.parse(task)).toMatchObject({
+      projectId: project.id,
+      status: 'done'
+    })
+  })
+
+  it('creates organization model and initialization fixtures', () => {
+    const model = makeOrganizationModel({
+      branding: { organizationName: 'Test Brand' }
+    })
+    const profile = makeUserProfile({ id: TEST_USERS.admin.id, email: TEST_USERS.admin.email })
+    const state = makeInitializationState({ profile, organizationReady: false, allReady: false })
+
+    expect(model.branding.organizationName).toBe('Test Brand')
+    expect(state.profile?.email).toBe(TEST_USERS.admin.email)
+    expect(state.organizationReady).toBe(false)
+  })
+
+  it('promotes existing fixture surface through the public barrel', () => {
+    expect(TEST_USERS.admin.email).toBe('admin@test.com')
+    expect(TEST_ORGS.acme.name).toBe('Acme Corp')
+  })
+})

package/src/organization-model/__tests__/domains/operations.test.ts

@@ -1,203 +0,0 @@
-import { describe, expect, it } from 'vitest'
-import {
-  DEFAULT_ORGANIZATION_MODEL_OPERATIONS,
-  OperationEntrySchema,
-  OperationsDomainSchema,
-  OperationSemanticClassSchema
-} from '../../domains/operations'
-
-// ---------------------------------------------------------------------------
-// Group 1: OperationEntrySchema — positive parse
-// ---------------------------------------------------------------------------
-
-describe('OperationEntrySchema — positive parse', () => {
-  it('accepts a fully-specified entry (id, label, semanticClass, featureId, supportedStatusSemanticClass)', () => {
-    const result = OperationEntrySchema.safeParse({
-      id: 'operations.queue',
-      label: 'HITL Queue',
-      semanticClass: 'queue',
-      featureId: 'operations',
-      supportedStatusSemanticClass: ['queue']
-    })
-    expect(result.success).toBe(true)
-  })
-
-  it('accepts a minimal entry without optional fields', () => {
-    const result = OperationEntrySchema.safeParse({
-      id: 'operations.sessions',
-      label: 'Sessions',
-      semanticClass: 'sessions'
-    })
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.featureId).toBeUndefined()
-      expect(result.data.supportedStatusSemanticClass).toBeUndefined()
-    }
-  })
-
-  it('trims whitespace from id and label', () => {
-    const result = OperationEntrySchema.safeParse({
-      id: '  trimmed-id  ',
-      label: '  Trimmed Label  ',
-      semanticClass: 'executions'
-    })
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.id).toBe('trimmed-id')
-      expect(result.data.label).toBe('Trimmed Label')
-    }
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Group 2: OperationEntrySchema — negative parse
-// ---------------------------------------------------------------------------
-
-describe('OperationEntrySchema — negative parse', () => {
-  it('rejects a missing id field', () => {
-    const result = OperationEntrySchema.safeParse({
-      label: 'No ID',
-      semanticClass: 'queue'
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects a missing label field', () => {
-    const result = OperationEntrySchema.safeParse({
-      id: 'operations.queue',
-      semanticClass: 'queue'
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects a missing semanticClass field', () => {
-    const result = OperationEntrySchema.safeParse({
-      id: 'operations.queue',
-      label: 'HITL Queue'
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects an unknown semanticClass value', () => {
-    const result = OperationEntrySchema.safeParse({
-      id: 'some.entry',
-      label: 'Some Entry',
-      semanticClass: 'not-a-real-class'
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects a non-string id (number)', () => {
-    const result = OperationEntrySchema.safeParse({
-      id: 42,
-      label: 'Label',
-      semanticClass: 'queue'
-    })
-    expect(result.success).toBe(false)
-  })
-
-  it('rejects an empty string label (min length 1 after trim)', () => {
-    const result = OperationEntrySchema.safeParse({
-      id: 'some.entry',
-      label: '   ',
-      semanticClass: 'queue'
-    })
-    expect(result.success).toBe(false)
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Group 3: OperationsDomainSchema — structural tests
-// ---------------------------------------------------------------------------
-
-describe('OperationsDomainSchema — structural tests', () => {
-  it('accepts an entries-empty domain object', () => {
-    const result = OperationsDomainSchema.safeParse({ entries: [] })
-    expect(result.success).toBe(true)
-  })
-
-  it('applies an empty-array default when entries is omitted', () => {
-    const result = OperationsDomainSchema.safeParse({})
-    expect(result.success).toBe(true)
-    if (result.success) {
-      expect(result.data.entries).toEqual([])
-    }
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Group 4: Semantic class enum — all 5 values declared
-// ---------------------------------------------------------------------------
-
-describe('OperationSemanticClassSchema — enum coverage', () => {
-  const expectedClasses = ['queue', 'executions', 'sessions', 'notifications', 'schedules'] as const
-
-  it('enum exposes exactly 5 semantic classes', () => {
-    expect(OperationSemanticClassSchema.options).toHaveLength(5)
-  })
-
-  it.each(expectedClasses)('"%s" is a valid semanticClass value', (cls) => {
-    const result = OperationSemanticClassSchema.safeParse(cls)
-    expect(result.success).toBe(true)
-  })
-
-  it('every entry in the seed uses one of the 5 known semanticClass values', () => {
-    const valid = new Set<string>(OperationSemanticClassSchema.options)
-    for (const entry of DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries) {
-      expect(
-        valid.has(entry.semanticClass),
-        `Unexpected semanticClass "${entry.semanticClass}" on entry "${entry.id}"`
-      ).toBe(true)
-    }
-  })
-
-  it('all 5 semanticClass values have exactly one seed entry', () => {
-    const presentClasses = new Set(DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.map((e) => e.semanticClass))
-    for (const cls of OperationSemanticClassSchema.options) {
-      expect(presentClasses.has(cls), `No seed entry found for semanticClass "${cls}"`).toBe(true)
-    }
-  })
-})
-
-// ---------------------------------------------------------------------------
-// Group 5: Seed completeness
-// ---------------------------------------------------------------------------
-
-describe('DEFAULT_ORGANIZATION_MODEL_OPERATIONS seed — completeness', () => {
-  it('has exactly 5 entries (one per entity category)', () => {
-    expect(DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries).toHaveLength(5)
-  })
-
-  it('all entry ids are unique', () => {
-    const ids = DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.map((e) => e.id)
-    const uniqueIds = new Set(ids)
-    expect(uniqueIds.size).toBe(ids.length)
-  })
-
-  it('every entry has a non-empty id, label, and semanticClass', () => {
-    for (const entry of DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries) {
-      expect(entry.id.length).toBeGreaterThan(0)
-      expect(entry.label.length).toBeGreaterThan(0)
-      expect(entry.semanticClass.length).toBeGreaterThan(0)
-    }
-  })
-
-  it('queue entry references queue status semantic class', () => {
-    const queueEntry = DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.find((e) => e.semanticClass === 'queue')
-    expect(queueEntry).toBeDefined()
-    expect(queueEntry?.supportedStatusSemanticClass).toContain('queue')
-  })
-
-  it('executions entry references execution status semantic class', () => {
-    const execEntry = DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.find((e) => e.semanticClass === 'executions')
-    expect(execEntry).toBeDefined()
-    expect(execEntry?.supportedStatusSemanticClass).toContain('execution')
-  })
-
-  it('schedules entry references schedule and schedule.run status semantic classes', () => {
-    const schedEntry = DEFAULT_ORGANIZATION_MODEL_OPERATIONS.entries.find((e) => e.semanticClass === 'schedules')
-    expect(schedEntry).toBeDefined()
-    expect(schedEntry?.supportedStatusSemanticClass).toContain('schedule')
-    expect(schedEntry?.supportedStatusSemanticClass).toContain('schedule.run')
-  })
-})

package/src/organization-model/domains/features.ts

@@ -1,31 +0,0 @@
-import { z } from 'zod'
-import { ColorTokenSchema, DescriptionSchema, IconNameSchema, LabelSchema, PathSchema } from './shared'
-
-export const NodeIdPathSchema = z
-  .string()
-  .trim()
-  .min(1)
-  .max(100)
-  .regex(/^([a-z0-9-]+)(\.[a-z0-9-]+)*$/, 'Node IDs must be lowercase dotted paths')
-
-export const NodeIdStringSchema = z
-  .string()
-  .trim()
-  .min(1)
-  .max(200)
-  .regex(/^[a-z]+:([a-z0-9-]+)(\.[a-z0-9-]+)*$/, 'Node references must use kind:dotted-path')
-
-export const UiPositionSchema = z.enum(['sidebar-primary', 'sidebar-bottom'])
-
-export const FeatureSchema = z.object({
-  id: NodeIdPathSchema,
-  label: LabelSchema,
-  description: DescriptionSchema.optional(),
-  enabled: z.boolean().default(true),
-  path: PathSchema.optional(),
-  icon: IconNameSchema.optional(),
-  color: ColorTokenSchema.optional(),
-  uiPosition: UiPositionSchema.optional(),
-  requiresAdmin: z.boolean().optional(),
-  devOnly: z.boolean().optional()
-})

package/src/organization-model/domains/operations.ts

@@ -1,85 +0,0 @@
-import { z } from 'zod'
-
-// ---------------------------------------------------------------------------
-// Semantic class enum — one value per stateful runtime entity category.
-// Every operation entry declares which category it belongs to via semanticClass.
-// ---------------------------------------------------------------------------
-
-export const OperationSemanticClassSchema = z.enum(['queue', 'executions', 'sessions', 'notifications', 'schedules'])
-
-// ---------------------------------------------------------------------------
-// Operation entry schema
-// ---------------------------------------------------------------------------
-
-export const OperationEntrySchema = z.object({
-  id: z.string().trim().min(1).max(100),
-  label: z.string().trim().min(1).max(120),
-  semanticClass: OperationSemanticClassSchema,
-  /** Optional reference to the feature that owns this runtime entity. */
-  featureId: z.string().trim().min(1).max(100).optional(),
-  /**
-   * Optional pointer to the status semanticClass values that apply to this
-   * entity — ties operations back to the statuses domain for vibe rendering.
-   */
-  supportedStatusSemanticClass: z.array(z.string().trim().min(1).max(80)).optional()
-})
-
-// ---------------------------------------------------------------------------
-// Domain schema — a flat array of operation entries
-// ---------------------------------------------------------------------------
-
-export const OperationsDomainSchema = z.object({
-  entries: z.array(OperationEntrySchema).default([])
-})
-
-// ---------------------------------------------------------------------------
-// Seed — one entry per stateful runtime entity category.
-// Categories: queue (HITL), executions, sessions, notifications, schedules.
-// ---------------------------------------------------------------------------
-
-export const DEFAULT_ORGANIZATION_MODEL_OPERATIONS: z.infer<typeof OperationsDomainSchema> = {
-  entries: [
-    // --- queue (HITL command queue) ---
-    {
-      id: 'operations.queue',
-      label: 'HITL Queue',
-      semanticClass: 'queue',
-      featureId: 'operations',
-      supportedStatusSemanticClass: ['queue']
-    },
-
-    // --- executions (workflow / agent executions) ---
-    {
-      id: 'operations.executions',
-      label: 'Executions',
-      semanticClass: 'executions',
-      featureId: 'operations',
-      supportedStatusSemanticClass: ['execution']
-    },
-
-    // --- sessions (agent conversation sessions) ---
-    {
-      id: 'operations.sessions',
-      label: 'Sessions',
-      semanticClass: 'sessions',
-      featureId: 'operations'
-    },
-
-    // --- notifications (platform in-app notifications) ---
-    {
-      id: 'operations.notifications',
-      label: 'Notifications',
-      semanticClass: 'notifications',
-      featureId: 'monitoring'
-    },
-
-    // --- schedules (task scheduler) ---
-    {
-      id: 'operations.schedules',
-      label: 'Schedules',
-      semanticClass: 'schedules',
-      featureId: 'operations',
-      supportedStatusSemanticClass: ['schedule', 'schedule.run']
-    }
-  ]
-}