.do Business-as-Code - AI & SDK

Everything is a Semantic Function

🌟 Features

Quick Start

SDK.do - TypeScript SDK with Semantic $ Proxy

pnpm install sdk.do

import $, { ai, api, db, on, send, every, user } from 'sdk.do'
// Semantic event patterns using $.Subject.predicate.Object
on($.Order.created, async (order) => {
 await send($.Invoice.generate, { orderId: order.id })
})
// Semantic database queries
const businesses = await db.list($.Business)
const brands = await db.related(business, $.owns, $.Brand)
// AI with semantic types
const content = await ai.generate({
 prompt: 'Write a blog post about AI',
 schema: $.BlogPosting,
})
// Schedule with semantic context
every($.Daily, async () => {
 await send($.Report.generate, { type: 'daily' })
})

CLI.do - Command Line Interface

pnpm install cli.do
# Use SDK functions from CLI
do db list Business
do ai generate "Write a haiku"
do send Order.created '{"id": "123"}'

MCP.do - Model Context Protocol Server

pnpm install mcp.do
# Expose SDK as MCP server
mcp start
# Use the 'do' tool in Claude Desktop
# Securely executes TypeScript with access to sdk.do

Packages

.org.ai Semantic Data Packages

Occupational Data (O*NET Database 30.0)

Business & Industry Data

Organizational Data

Platform & Content

Source Data Packages

Semantic Graph & Types

import $ from 'graphdl'
import { graph, node, edge, createTriple } from 'graphdl'
// Create semantic paths
const path = $.Person.worksFor.Organization
console.log(String(path)) // "$.Person.worksFor.Organization"
// Build knowledge graphs
const myGraph = graph()
 .context('https://schema.org')
 .node(node('john', 'Person', { name: 'John Doe' }))
 .node(node('acme', 'Organization', { name: 'Acme Corp' }))
 .edge(edge('john', 'worksFor', 'acme'))
 .build()
// Create triples
const triple = createTriple('Person:john', 'worksFor', 'Organization:acme', {
 context: 'https://schema.org',
})

---
$id: https://example.com/person/john
$type: Person
name: John Doe
jobTitle: Software Engineer
worksFor:
 $type: Organization
 $id: https://example.com/org/acme
 name: Acme Corp
---
# About John
John is a software engineer at Acme Corp.

Schema.org Vocabularies

import type { Organization, Person, BlogPosting } from 'schema.org.ai'
const business: Organization = {
 $type: 'Organization',
 $id: 'acme-corp',
 name: 'Acme Corp',
 employee: [
 {
 $type: 'Person',
 $id: 'john-doe',
 name: 'John Doe',
 },
 ],
}

import type { ObjectEvent, Trade Item, Party } from 'gs1.org.ai'
// Supply chain semantic paths
$.Shipment.inTransit.Warehouse
$.Product.receiving.DistributionCenter
$.TradeItem.locatedAt.Location

import type { Occupation, Skill, Ability } from 'soc.org.ai'
// Occupation semantic paths
$.Person.hasOccupation.Occupation
$.Occupation.requiresSkill.Programming
$.SoftwareDeveloper.requiresAbility.CriticalThinking

Edge & API Tools

SDK.do API

$ - Semantic Context Proxy

import $ from 'sdk.do'
// Create semantic paths
$.Person.worksFor.Organization
$.Order.created.Customer
$.Invoice.paid.StripeCustomer
$.Business.owns.Brand
// Use in events
on($.Order.created, handler)
send($.Invoice.paid, data)
// Use in database queries
await db.list($.Business)
await db.get($.Person, 'john-doe')
// Access with brackets for dynamic keys
$.Person['john-doe'].worksFor.Organization['acme']

ai - AI Services

import { ai } from 'sdk.do'
// Generate text
const text = await ai.generate({
 prompt: 'Write a haiku about code',
 model: 'claude-3-5-sonnet',
})
// Generate with schema
const content = await ai.generate({
 prompt: 'Create a blog post',
 schema: $.BlogPosting,
})
// Create embeddings
const embeddings = await ai.embed('Hello world')
// Batch processing
const results = await ai.batch([{ prompt: 'Prompt 1' }, { prompt: 'Prompt 2' }])

db - Semantic Database

import { db } from 'sdk.do'
// List by semantic type
const businesses = await db.list($.Business)
const people = await db.list($.Person, {
 where: { jobTitle: 'Engineer' },
})
// Get by semantic type and ID
const business = await db.get($.Business, 'acme-corp')
const person = await db.get($.Person, 'john-doe')
// Create with semantic type
await db.create($.Blog, {
 $id: 'engineering-blog',
 $type: $.Blog,
 name: 'Engineering Blog',
 publisher: $.Brand['acme'],
})
// Update
await db.update($.Person, 'john-doe', {
 jobTitle: 'Senior Engineer',
})
// Delete
await db.delete($.Person, 'john-doe')
// Query relationships
const brands = await db.related(business, $.owns, $.Brand)
const employees = await db.related(business, $.employs, $.Person)
// Create relationships
await db.relate(business, $.owns, brand)
await db.relate(person, $.worksFor, organization)

on - Event Listeners

import { on } from 'sdk.do'
// Listen for semantic events
on($.Order.created, async (order) => {
 console.log('Order created:', order)
 await processOrder(order)
})
on($.Invoice.paid, async (invoice) => {
 console.log('Invoice paid:', invoice)
 await fulfillOrder(invoice.orderId)
})
// Pattern matching
on($.*.created, async (entity) => {
 console.log('Entity created:', entity.$type, entity.$id)
})
// Multiple event types
on([$.Order.created, $.Order.updated], async (order) => {
 await updateInventory(order)
})

send - Event Publishing

import { send } from 'sdk.do'
// Send semantic events
await send($.Order.created, {
 $type: $.Order,
 $id: 'order-123',
 customer: 'customer-456',
 total: 99.99,
})
await send($.Invoice.paid, {
 $type: $.Invoice,
 $id: 'invoice-789',
 orderId: 'order-123',
 amount: 99.99,
})
// Broadcast to multiple listeners
await send($.Customer.registered, {
 $type: $.Person,
 $id: 'customer-456',
 email: 'customer@example.com',
})

every - Scheduled Workflows

import { every } from 'sdk.do'
// Run on schedule
every($.Daily, async () => {
 await send($.Report.generate, { type: 'daily' })
})
every($.Hourly, async () => {
 await send($.Metrics.collect, { interval: 'hourly' })
})
every($.Weekly, async () => {
 await send($.Newsletter.send, { day: 'monday' })
})
// Custom cron expressions
every('0 0 * * *', async () => {
 await send($.Backup.create, { type: 'full' })
})

api - External Integrations

import { api } from 'sdk.do'
// Access external APIs with semantic context
const customer = await api.stripe.customers.create({
 email: 'customer@example.com',
 metadata: {
 $type: $.Person,
 $id: 'customer-123',
 },
})
// Call any API
const data = await api.fetch('https://api.example.com/data', {
 method: 'POST',
 body: JSON.stringify({ key: 'value' }),
})

user - User Context

import { user } from 'sdk.do'
// Get current user
const currentUser = await user.current()
// Get session
const session = await user.session()
// Check permissions
const canEdit = await user.can('edit', $.Blog)
const canDelete = await user.can('delete', $.Blog, 'blog-123')
// Get user data
const userId = user.id
const userEmail = user.email
const userRoles = user.roles

Semantic Patterns

Business Relationships

// Organization relationships
$.Organization.owns.Brand
$.Organization.employs.Person
$.Organization.provides.Service
$.Organization.locatedIn.Place
// Person relationships
$.Person.worksFor.Organization
$.Person.hasOccupation.Occupation
$.Person.knows.Person
$.Person.owns.Property
// Product relationships
$.Product.manufacturer.Organization
$.Product.brand.Brand
$.Product.category.Category
$.Product.soldBy.Seller

Event Patterns

// Lifecycle events
$.Entity.created
$.Entity.updated
$.Entity.deleted
$.Entity.archived
// Business events
$.Order.created
$.Order.confirmed
$.Order.shipped
$.Order.delivered
$.Order.cancelled
// Payment events
$.Invoice.generated
$.Invoice.sent
$.Invoice.paid
$.Invoice.overdue
// User events
$.User.registered
$.User.authenticated
$.User.verified
$.User.deactivated

Workflow Patterns

// Sequential workflow
on($.Order.created, async (order) => {
 await send($.Order.confirm, order)
})
on($.Order.confirmed, async (order) => {
 await send($.Inventory.reserve, order)
})
on($.Inventory.reserved, async (reservation) => {
 await send($.Shipment.create, reservation)
})
// Parallel workflow
on($.Customer.registered, async (customer) => {
 await Promise.all([send($.Email.welcome, customer), send($.Stripe.Customer.create, customer), send($.Analytics.track, { event: 'registration', customer })])
})
// Conditional workflow
on($.Order.created, async (order) => {
 if (order.total > 100) {
 await send($.Discount.apply, { order, discount: 0.1 })
 }
 await send($.Order.process, order)
})

Architecture

ai/
├── packages/
│ ├── sdk.do/ # Core SDK with $ proxy
│ ├── cli.do/ # CLI interface
│ ├── mcp.do/ # MCP server
│ ├── graphdl/ # Semantic graphs
│ ├── mdxld/ # Linked data in MDX
│ ├── schema.org.ai/ # Schema.org types
│ ├── gs1.org.ai/ # GS1 supply chain
│ ├── soc.org.ai/ # O*NET occupations
│ ├── edge-api/ # Edge utilities
│ └── buildercss/ # CSS-in-JS
└── sdk/ # SDK documentation

Development

Local Development

# Clone the repository
git clone https://github.com/dot-do/ai.git
cd ai
# Install dependencies
pnpm install
# Build all packages
pnpm build
# Run tests
pnpm test
# Run tests in watch mode
pnpm test:watch
# Type checking
pnpm typecheck
# Lint code
pnpm lint
pnpm lint:fix
# Format code
pnpm format

Package Development

# Navigate to specific package
cd packages/sdk.do
# Build package
pnpm build
# Run tests
pnpm test
# Link for local development
pnpm link --global

Creating a New Package

# Copy template
cp -r packages/.template packages/my-package
# Update package.json name and description
# Implement package in src/
# Add tests in test/

Contributing

How to Contribute

Contribution Guidelines

Code Standards

Areas We Need Help

Documentation

Package Documentation

Additional Resources

Community

Get Help

Stay Updated

Contributing

Related Projects

License

Acknowledgments