services-as-software 2.1.1 → 2.1.3

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
 
-> services-as-software@2.0.1 build /Users/nathanclevenger/projects/primitives.org.ai/packages/services-as-software
+> services-as-software@2.1.3 build /Users/nathanclevenger/projects/primitives.org.ai/packages/services-as-software
 > tsc
 

package/CHANGELOG.md

@@ -1,5 +1,14 @@
 # services-as-software
 
+## 2.1.3
+
+### Patch Changes
+
+- Updated dependencies
+  - ai-functions@2.1.3
+  - ai-database@2.1.3
+  - digital-workers@2.1.3
+
 ## 2.1.1
 
 ### Patch Changes

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 .org.ai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "services-as-software",
-  "version": "2.1.1",
+  "version": "2.1.3",
   "description": "Primitives for building AI-powered services that operate as software",
   "type": "module",
   "main": "dist/index.js",
@@ -11,18 +11,10 @@
       "types": "./dist/index.d.ts"
     }
   },
-  "scripts": {
-    "build": "tsc",
-    "dev": "tsc --watch",
-    "test": "vitest",
-    "typecheck": "tsc --noEmit",
-    "lint": "eslint .",
-    "clean": "rm -rf dist"
-  },
   "dependencies": {
-    "ai-database": "2.1.1",
-    "ai-functions": "2.1.1",
-    "digital-workers": "2.1.1"
+    "ai-database": "2.1.3",
+    "ai-functions": "2.1.3",
+    "digital-workers": "2.1.3"
   },
   "keywords": [
     "services",
@@ -30,5 +22,13 @@
     "ai",
     "primitives"
   ],
-  "license": "MIT"
-}
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
+    "clean": "rm -rf dist"
+  }
+}

package/tests/communication.test.ts

@@ -0,0 +1,517 @@
+/**
+ * Client Communication Tests
+ *
+ * Tests for automated client communication and notifications.
+ */
+
+import { describe, it, expect, vi } from 'vitest'
+import {
+  createCommunicationChannel,
+  sendNotification,
+  scheduleNotification,
+  createNotificationTemplate,
+  buildCommunicationWorkflow,
+  trackCommunication,
+  CommunicationType,
+  NotificationPriority,
+} from '../src/communication/index.js'
+
+describe('Client Communication Automation', () => {
+  describe('Communication Channels', () => {
+    it('should create an email channel', () => {
+      const channel = createCommunicationChannel({
+        type: 'email',
+        name: 'Customer Email',
+        config: {
+          from: 'support@service.com',
+          replyTo: 'help@service.com',
+        },
+      })
+
+      expect(channel.type).toBe('email')
+      expect(channel.config.from).toBe('support@service.com')
+    })
+
+    it('should create a Slack channel', () => {
+      const channel = createCommunicationChannel({
+        type: 'slack',
+        name: 'Customer Slack',
+        config: {
+          webhookUrl: 'https://hooks.slack.com/...',
+          defaultChannel: '#client-updates',
+        },
+      })
+
+      expect(channel.type).toBe('slack')
+    })
+
+    it('should create an SMS channel', () => {
+      const channel = createCommunicationChannel({
+        type: 'sms',
+        name: 'Customer SMS',
+        config: {
+          provider: 'twilio',
+          fromNumber: '+15551234567',
+        },
+      })
+
+      expect(channel.type).toBe('sms')
+    })
+
+    it('should create a webhook channel', () => {
+      const channel = createCommunicationChannel({
+        type: 'webhook',
+        name: 'Customer Webhook',
+        config: {
+          url: 'https://customer.com/webhooks/updates',
+          headers: { 'X-API-Key': '{{apiKey}}' },
+          method: 'POST',
+        },
+      })
+
+      expect(channel.type).toBe('webhook')
+    })
+  })
+
+  describe('Notifications', () => {
+    it('should send a notification', async () => {
+      const sendMock = vi.fn().mockResolvedValue({ messageId: 'msg-123' })
+
+      const result = await sendNotification({
+        to: 'client@example.com',
+        channel: 'email',
+        subject: 'Project Update',
+        body: 'Your project has been completed.',
+        priority: 'normal',
+      })
+
+      expect(result.sent).toBe(true)
+      expect(result.messageId).toBeDefined()
+    })
+
+    it('should send notification with template', async () => {
+      const template = createNotificationTemplate({
+        id: 'project-complete',
+        name: 'Project Completion',
+        subject: 'Your {{projectName}} project is complete!',
+        body: `
+          Hi {{clientName}},
+
+          Great news! Your project "{{projectName}}" has been completed.
+
+          Deliverables:
+          {{#each deliverables}}
+          - {{this}}
+          {{/each}}
+
+          Please review and let us know if you have any questions.
+
+          Best regards,
+          {{teamName}}
+        `,
+      })
+
+      const result = await sendNotification({
+        to: 'client@example.com',
+        channel: 'email',
+        template: template.id,
+        variables: {
+          clientName: 'John',
+          projectName: 'Website Redesign',
+          deliverables: ['Homepage', 'About Page', 'Contact Form'],
+          teamName: 'Design Team',
+        },
+      })
+
+      expect(result.sent).toBe(true)
+    })
+
+    it('should handle multiple recipients', async () => {
+      const result = await sendNotification({
+        to: ['client1@example.com', 'client2@example.com'],
+        channel: 'email',
+        subject: 'Team Update',
+        body: 'Project update for all stakeholders.',
+      })
+
+      expect(result.recipients).toHaveLength(2)
+      expect(result.successCount).toBe(2)
+    })
+
+    it('should support priority levels', async () => {
+      const result = await sendNotification({
+        to: 'client@example.com',
+        channel: 'email',
+        subject: 'Urgent: Action Required',
+        body: 'Please review immediately.',
+        priority: 'urgent',
+      })
+
+      expect(result.priority).toBe('urgent')
+    })
+
+    it('should handle notification failures', async () => {
+      const result = await sendNotification({
+        to: 'invalid-email',
+        channel: 'email',
+        subject: 'Test',
+        body: 'Test',
+      })
+
+      expect(result.sent).toBe(false)
+      expect(result.error).toBeDefined()
+    })
+  })
+
+  describe('Scheduled Notifications', () => {
+    it('should schedule a notification', async () => {
+      const scheduled = await scheduleNotification({
+        to: 'client@example.com',
+        channel: 'email',
+        subject: 'Weekly Summary',
+        body: 'Here is your weekly summary...',
+        scheduledFor: new Date('2024-01-15T09:00:00Z'),
+      })
+
+      expect(scheduled.id).toBeDefined()
+      expect(scheduled.status).toBe('scheduled')
+      expect(scheduled.scheduledFor).toEqual(new Date('2024-01-15T09:00:00Z'))
+    })
+
+    it('should schedule recurring notifications', async () => {
+      const scheduled = await scheduleNotification({
+        to: 'client@example.com',
+        channel: 'email',
+        subject: 'Weekly Progress Report',
+        body: 'Here is this week\'s progress...',
+        schedule: {
+          type: 'recurring',
+          cron: '0 9 * * 1', // Every Monday at 9am
+          timezone: 'America/New_York',
+        },
+      })
+
+      expect(scheduled.recurring).toBe(true)
+      expect(scheduled.nextRun).toBeDefined()
+    })
+
+    it('should cancel scheduled notification', async () => {
+      const scheduled = await scheduleNotification({
+        to: 'client@example.com',
+        channel: 'email',
+        subject: 'Test',
+        body: 'Test',
+        scheduledFor: new Date('2024-12-31'),
+      })
+
+      const result = await scheduled.cancel()
+
+      expect(result.cancelled).toBe(true)
+      expect(result.status).toBe('cancelled')
+    })
+  })
+
+  describe('Notification Templates', () => {
+    it('should create a notification template', () => {
+      const template = createNotificationTemplate({
+        id: 'welcome',
+        name: 'Welcome Email',
+        subject: 'Welcome to {{serviceName}}!',
+        body: 'Hi {{name}}, welcome aboard!',
+        variables: ['serviceName', 'name'],
+      })
+
+      expect(template.id).toBe('welcome')
+      expect(template.variables).toContain('name')
+    })
+
+    it('should support multiple channels', () => {
+      const template = createNotificationTemplate({
+        id: 'status-update',
+        name: 'Status Update',
+        channels: {
+          email: {
+            subject: 'Project Status: {{status}}',
+            body: 'Your project status has changed to {{status}}.',
+          },
+          slack: {
+            message: ':bell: Project status changed to *{{status}}*',
+          },
+          sms: {
+            message: 'Project status: {{status}}',
+          },
+        },
+      })
+
+      expect(template.channels.email).toBeDefined()
+      expect(template.channels.slack).toBeDefined()
+      expect(template.channels.sms).toBeDefined()
+    })
+
+    it('should validate template variables', () => {
+      const template = createNotificationTemplate({
+        id: 'test',
+        name: 'Test',
+        subject: 'Hello {{name}}',
+        body: 'Welcome {{name}}, your ID is {{userId}}',
+        validation: {
+          name: { required: true, type: 'string' },
+          userId: { required: true, type: 'string' },
+        },
+      })
+
+      expect(() => template.render({ name: 'John' })).toThrow() // missing userId
+    })
+
+    it('should support conditional content', () => {
+      const template = createNotificationTemplate({
+        id: 'invoice',
+        name: 'Invoice',
+        body: `
+          Amount due: {{amount}}
+          {{#if overdue}}
+          This invoice is overdue. Please pay immediately.
+          {{/if}}
+        `,
+      })
+
+      const rendered = template.render({
+        amount: '$100',
+        overdue: true,
+      })
+
+      expect(rendered).toContain('overdue')
+    })
+  })
+
+  describe('Communication Workflows', () => {
+    it('should build a communication workflow', () => {
+      const workflow = buildCommunicationWorkflow({
+        name: 'Project Lifecycle',
+        triggers: [
+          { event: 'project.started', template: 'project-started' },
+          { event: 'milestone.completed', template: 'milestone-update' },
+          { event: 'review.requested', template: 'review-request' },
+          { event: 'project.completed', template: 'project-complete' },
+        ],
+      })
+
+      expect(workflow.name).toBe('Project Lifecycle')
+      expect(workflow.triggers).toHaveLength(4)
+    })
+
+    it('should handle conditional notifications', async () => {
+      const workflow = buildCommunicationWorkflow({
+        name: 'Conditional Workflow',
+        triggers: [
+          {
+            event: 'payment.received',
+            template: 'payment-receipt',
+            condition: (ctx) => ctx.amount > 0,
+          },
+          {
+            event: 'payment.failed',
+            template: 'payment-failed',
+            condition: (ctx) => ctx.retryCount < 3,
+          },
+        ],
+      })
+
+      const result = await workflow.process({
+        event: 'payment.received',
+        amount: 100,
+      })
+
+      expect(result.notificationSent).toBe(true)
+    })
+
+    it('should support notification delays', async () => {
+      const workflow = buildCommunicationWorkflow({
+        name: 'Delayed Workflow',
+        triggers: [
+          {
+            event: 'trial.started',
+            template: 'trial-welcome',
+          },
+          {
+            event: 'trial.started',
+            template: 'trial-day-3',
+            delay: '3d',
+          },
+          {
+            event: 'trial.started',
+            template: 'trial-ending',
+            delay: '12d',
+          },
+        ],
+      })
+
+      const scheduled = await workflow.process({
+        event: 'trial.started',
+        userId: 'user-123',
+      })
+
+      expect(scheduled).toHaveLength(3)
+      expect(scheduled[1].delay).toBe('3d')
+    })
+
+    it('should cancel pending notifications on event', async () => {
+      const workflow = buildCommunicationWorkflow({
+        name: 'Cancellable Workflow',
+        triggers: [
+          {
+            event: 'reminder.scheduled',
+            template: 'reminder',
+            cancelOnEvents: ['task.completed', 'task.cancelled'],
+          },
+        ],
+      })
+
+      // Schedule reminder
+      await workflow.process({
+        event: 'reminder.scheduled',
+        taskId: 'task-123',
+      })
+
+      // Complete task (should cancel reminder)
+      const result = await workflow.process({
+        event: 'task.completed',
+        taskId: 'task-123',
+      })
+
+      expect(result.cancelledNotifications).toHaveLength(1)
+    })
+  })
+
+  describe('Communication Tracking', () => {
+    it('should track sent communications', async () => {
+      await sendNotification({
+        to: 'client@example.com',
+        channel: 'email',
+        subject: 'Test',
+        body: 'Test',
+      })
+
+      const tracking = await trackCommunication.get({
+        recipient: 'client@example.com',
+        timeRange: '24h',
+      })
+
+      expect(tracking.messages).toHaveLength(1)
+    })
+
+    it('should track email opens', async () => {
+      const result = await sendNotification({
+        to: 'client@example.com',
+        channel: 'email',
+        subject: 'Test',
+        body: 'Test',
+        tracking: {
+          opens: true,
+          clicks: true,
+        },
+      })
+
+      // Simulate open
+      await trackCommunication.recordOpen(result.messageId)
+
+      const tracking = await trackCommunication.get({ messageId: result.messageId })
+      expect(tracking.opened).toBe(true)
+      expect(tracking.openedAt).toBeDefined()
+    })
+
+    it('should track link clicks', async () => {
+      const result = await sendNotification({
+        to: 'client@example.com',
+        channel: 'email',
+        subject: 'Test',
+        body: '<a href="https://example.com">Click here</a>',
+        tracking: { clicks: true },
+      })
+
+      // Simulate click
+      await trackCommunication.recordClick(result.messageId, 'https://example.com')
+
+      const tracking = await trackCommunication.get({ messageId: result.messageId })
+      expect(tracking.clicks).toHaveLength(1)
+      expect(tracking.clicks[0].url).toBe('https://example.com')
+    })
+
+    it('should generate communication analytics', async () => {
+      const analytics = await trackCommunication.getAnalytics({
+        channel: 'email',
+        timeRange: '30d',
+      })
+
+      expect(analytics.sent).toBeDefined()
+      expect(analytics.delivered).toBeDefined()
+      expect(analytics.opened).toBeDefined()
+      expect(analytics.clicked).toBeDefined()
+      expect(analytics.bounced).toBeDefined()
+      expect(analytics.openRate).toBeDefined()
+      expect(analytics.clickRate).toBeDefined()
+    })
+  })
+
+  describe('Client Preferences', () => {
+    it('should respect communication preferences', async () => {
+      const preferences = {
+        email: true,
+        sms: false,
+        slack: true,
+        preferredTime: '09:00-17:00',
+        timezone: 'America/New_York',
+      }
+
+      const result = await sendNotification({
+        to: 'client@example.com',
+        channels: ['email', 'sms', 'slack'],
+        subject: 'Update',
+        body: 'Your update',
+        respectPreferences: true,
+        clientPreferences: preferences,
+      })
+
+      expect(result.channelsUsed).toContain('email')
+      expect(result.channelsUsed).toContain('slack')
+      expect(result.channelsUsed).not.toContain('sms')
+    })
+
+    it('should handle do-not-disturb', async () => {
+      const result = await sendNotification({
+        to: 'client@example.com',
+        channel: 'email',
+        subject: 'Test',
+        body: 'Test',
+        priority: 'normal',
+        clientPreferences: {
+          doNotDisturb: {
+            enabled: true,
+            hours: '22:00-08:00',
+          },
+        },
+        currentTime: new Date('2024-01-15T23:00:00'),
+      })
+
+      expect(result.queued).toBe(true)
+      expect(result.queuedUntil).toBeDefined()
+    })
+
+    it('should allow urgent notifications to bypass preferences', async () => {
+      const result = await sendNotification({
+        to: 'client@example.com',
+        channel: 'sms',
+        subject: 'Urgent',
+        body: 'Urgent message',
+        priority: 'urgent',
+        clientPreferences: {
+          sms: false,
+        },
+        bypassPreferencesForUrgent: true,
+      })
+
+      expect(result.sent).toBe(true)
+      expect(result.bypassedPreferences).toBe(true)
+    })
+  })
+})