business-as-code 0.0.2 → 0.1.0

package/README.md

@@ -1,431 +1,234 @@
+# business-as-code
+
 [![npm version](https://img.shields.io/npm/v/business-as-code.svg)](https://www.npmjs.com/package/business-as-code)
-[![npm downloads](https://img.shields.io/npm/dm/business-as-code.svg)](https://www.npmjs.com/package/business-as-code)
 [![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
-[![TypeScript](https://img.shields.io/badge/TypeScript-5.0+-blue.svg)](https://www.typescriptlang.org/)
-[![Discord](https://img.shields.io/badge/Discord-Join%20Chat-7289da?logo=discord&logoColor=white)](https://discord.gg/tafnNeUQdm)
-[![GitHub Issues](https://img.shields.io/github/issues/drivly/ai.svg)](https://github.com/drivly/ai/issues)
-[![GitHub Stars](https://img.shields.io/github/stars/drivly/ai.svg)](https://github.com/drivly/ai)
-
-# business-as-code
 
-> Build, define, launch, experiment, iterate, and grow your business entirely in code.
+> Define, launch, experiment, iterate, and grow your business entirely in code
 
 ## Overview
 
-Business-as-Code represents a revolutionary approach to defining, operating, and scaling businesses. It moves beyond traditional methods by enabling the entire business lifecycle—from initial concept and strategy to execution and iteration—to be managed through clean, structured, and executable code.
-
-This paradigm builds upon core primitives like Functions, Workflows, and Agents, allowing complex business logic, processes, and even autonomous operations to be codified. By treating the business itself as a software system, we unlock unprecedented levels of agility, transparency, experimentation, and optimization.
-
-Drawing inspiration from the principles outlined in the [Manifesto](/docs/manifesto) and leveraging the foundational [Primitives](/docs/primitives) of the [.do](https://dotdo.ai) ecosystem, `business-as-code` provides the framework to transform strategic objectives into measurable outcomes through code.
+`business-as-code` enables organizations to represent their businesses and processes in code for human-AI collaboration. Unlike `ai-business` which focuses on AI-only businesses, this package provides interfaces for integrating human roles, AI agents, and defining collaboration points between them.
 
-## Declarative vs. Imperative Approaches
+## Installation
 
-The `business-as-code` package supports two complementary approaches to defining and executing business logic:
+```bash
+npm install business-as-code
+# or
+yarn add business-as-code
+# or
+pnpm add business-as-code
+```
 
-### Declarative Approach
+## Usage
 
-Define your business at a high level using objectives and key results (OKRs). The system, powered by AI, determines the optimal implementation strategy. This approach is ideal for setting strategic direction and allowing flexibility in execution.
+### Creating a Business with Human-AI Collaboration
 
 ```typescript
 import { Business } from 'business-as-code'
-
-const myBusiness = Business({
-  name: 'TechInnovators',
-  vision: 'Democratize AI for small businesses',
-  objectives: {
-    customerSuccess: {
-      description: 'Create delighted customers who achieve their goals',
-      keyResults: [
-        'Achieve 95% customer satisfaction score by Q4',
-        'Reduce average support ticket resolution time by 30% within 6 months',
-        'Increase customer retention rate to 85% year-over-year',
-      ]
+import { Human } from 'humans.do'
+import { Agent } from 'agents.do'
+import { Workflow } from 'workflows.do'
+
+// Create human roles
+class CEO extends Human {}
+class CTO extends Human {}
+class MarketingManager extends Human {}
+
+// Create AI agents
+class DataAnalyst extends Agent {}
+class CustomerSupportAgent extends Agent {}
+
+// Create business processes
+class CustomerOnboarding extends Workflow {}
+class ProductDevelopment extends Workflow {}
+
+// Define your business
+const myCompany = Business({
+  name: 'Acme Corporation',
+  url: 'https://acme.com',
+  vision: 'To revolutionize industry X with innovative solutions',
+  goals: [
+    {
+      objective: 'Increase market share by 20%',
+      keyResults: ['Launch 3 new products', 'Expand to 2 new geographical markets', 'Increase customer retention by 15%'],
     },
-    productInnovation: {
-      description: 'Continuously deliver cutting-edge AI solutions',
-      keyResults: [
-        'Launch 3 new major features based on customer feedback this year',
-        'Secure 2 patents for novel AI algorithms',
-        'Increase R&D investment by 15% annually',
-      ]
+  ],
+  // Human roles
+  roles: {
+    ceo: CEO,
+    cto: CTO,
+    marketingManager: MarketingManager,
+  },
+  // AI agents
+  agents: {
+    dataAnalyst: DataAnalyst,
+    customerSupport: CustomerSupportAgent,
+  },
+  // Organizational structure
+  departments: {
+    engineering: {
+      name: 'Engineering Department',
+      lead: CTO,
+      members: [DataAnalyst],
     },
-    // More objectives...
-  }
+    marketing: {
+      name: 'Marketing Department',
+      lead: MarketingManager,
+      members: [],
+    },
+  },
+  // Business processes
+  processes: {
+    customerOnboarding: CustomerOnboarding,
+    productDevelopment: ProductDevelopment,
+  },
 })
 
-// Let the AI determine and execute the best approach to achieve the objectives
-await myBusiness.execute()
-```
-
-### Imperative Approach
-
-Define specific processes step-by-step using workflows. This approach provides fine-grained control over execution and is suitable for well-defined, repeatable tasks. It leverages the patterns established in [Workflows.do](https://workflows.do).
-
-```typescript
-import { Workflow } from 'workflows.do' // Assuming Workflow comes from workflows.do
-
-const customerOnboarding = Workflow({
-  name: 'CustomerOnboarding',
-  
-  onCustomerSignup: async ({ ai, api, db, event }) => {
-    const { name, email, company } = event
-    
-    // Step 1: Enrich contact details using Integrations.do
-    const enrichedContact = await api.apollo.search({ name, email, company })
-    
-    // Step 2: Analyze company background using Functions.do
-    const companyProfile = await ai.researchCompany({ company: enrichedContact.companyName || company })
-    
-    // Step 3: Personalize welcome email using Functions.do
-    const welcomeEmail = await ai.personalizeWelcomeEmail({ 
-      name, 
-      companyProfile 
-    })
-    
-    // Step 4: Send email using Integrations.do
-    await api.sendgrid.sendEmail({ 
-      to: email, 
-      subject: 'Welcome to TechInnovators!', // Hardcoded name for example clarity
-      body: welcomeEmail.content 
-    })
-    
-    // Step 5: Create user record in Database.do
-    await db.users.create({ 
-      name, 
-      email, 
-      company: enrichedContact.companyName || company, 
-      enrichedData: enrichedContact 
-    })
-
-    // Step 6: Notify team via Slack using Integrations.do
-     await api.slack.postMessage({
-      channel: '#signups',
-      content: `New signup: ${name} from ${company}`,
-    })
-  }
+// Event handling
+myCompany.on('new_customer', (data) => {
+  // Trigger customer onboarding workflow
+  console.log(`New customer: ${data.name}`)
 })
-```
-
-### Integration Between Approaches
-
-The true power emerges when combining both approaches. Define high-level business goals declaratively, and implement specific, critical processes imperatively within the same framework.
-
-```typescript
-const combinedBusiness = Business({
-  name: 'HybridSolutions',
-  vision: '...',
-  objectives: { /* ... */ },
-
-  // Define specific workflows imperatively
-  workflows: {
-    customerOnboarding, // Reuse the imperative workflow defined above
-    // Add other critical workflows...
-  },
 
-  // Define autonomous agents
-  agents: {
-    // Agents can leverage both declarative goals and imperative workflows
-  }
+// Scheduled operations
+myCompany.every('day', () => {
+  // Daily operations
+  console.log('Performing daily operations')
 })
 
-// Execute the business, allowing AI to manage undeclared processes
-// while respecting the defined imperative workflows.
-await combinedBusiness.launch() 
-```
+// Task assignment
+myCompany.assign('Analyze quarterly sales data', myCompany.agents.dataAnalyst)
+myCompany.assign('Review marketing strategy', myCompany.roles.marketingManager)
 
-## Core Primitives
+// Track business metrics
+myCompany.track('customer_satisfaction', 4.8)
+myCompany.track('monthly_revenue', 125000)
+```
 
-Business-as-Code builds upon a foundation of powerful, composable primitives inherited from the [.do](https://dotdo.ai) ecosystem:
+## Differences from `ai-business`
 
-- **[Functions](/docs/functions)**: The atomic units of work. They can be deterministic code, AI-driven generation, autonomous agent tasks, or even human actions, all with strongly-typed inputs and outputs.
-- **[Workflows](/docs/workflows)**: Orchestrate Functions into reliable, repeatable business processes. They combine different function types (Code, Generative, Agent, Human) to achieve specific outcomes aligned with business goals.
-- **[Agents](/docs/agents)**: Autonomous digital workers driven by goals and measured by key results. They execute tasks, interact within workflows, and leverage Functions and external integrations.
+While `ai-business` focuses on AI-driven business functions, `business-as-code` is designed specifically for representing existing organizations with both human employees and AI agents:
 
-These primitives provide the building blocks for codifying every aspect of a business.
+| Feature              | business-as-code                   | ai-business                    |
+| -------------------- | ---------------------------------- | ------------------------------ |
+| Primary focus        | Human-AI collaboration             | AI-driven business functions   |
+| Organizational model | Comprehensive (roles, departments) | Limited (focused on functions) |
+| Human roles          | Explicit role definitions          | Not specifically modeled       |
+| Decision approval    | Built-in approval workflows        | Automated decision making      |
+| Task assignment      | Supports both humans and AI        | Primarily AI-focused           |
+| Integration          | Designed for existing org systems  | Standalone AI capabilities     |
 
-## Business Model Components
+## Key Design Considerations
 
-Define key aspects of your business model directly in code. This allows for a structured, version-controlled representation of your strategy, integrating frameworks like Lean Canvas or StoryBrand.
+### 1. Organizational hierarchy
 
 ```typescript
-import { Business } from 'business-as-code'
-import { LeanCanvas, StoryBrand } from 'business-model-components' // Hypothetical import
-
-const myStartup = Business({
-  name: 'AgileAI',
-  vision: 'Empower teams with AI-driven project management',
-  objectives: { /* ... */ },
-
-  // Define business model using structured components
-  businessModel: {
-    leanCanvas: LeanCanvas({
-      problem: ['Inefficient project tracking', 'Poor resource allocation'],
-      solution: 'AI-powered platform for automated task management and prediction',
-      keyMetrics: ['Daily active users', 'Project completion rate'],
-      uniqueValueProposition: 'Effortless project management with predictive insights',
-      unfairAdvantage: 'Proprietary predictive algorithms',
-      channels: ['Direct sales', 'Content marketing'],
-      customerSegments: ['Software development teams', 'Marketing agencies'],
-      costStructure: ['Cloud hosting', 'R&D salaries', 'Sales commissions'],
-      revenueStreams: ['SaaS subscription tiers', 'Premium support'],
-    }),
-    storyBrand: StoryBrand({
-      character: 'Project Managers',
-      problem: 'Overwhelmed by complexity and delays',
-      plan: 'Implement AgileAI for streamlined workflows',
-      success: 'Effortless project delivery and happy teams',
-      failure: 'Continued chaos and missed deadlines',
-    }),
-    // Add other relevant model components...
+// Define departments with reporting lines
+const company = Business({
+  departments: {
+    engineering: {
+      name: 'Engineering',
+      lead: CTO,
+      members: [SeniorEngineer, JuniorEngineer, AICodeReviewer],
+    },
   },
-
-  workflows: { /* ... */ },
-  agents: { /* ... */ },
 })
-
-await myStartup.launch()
 ```
 
-## Experimentation and Iteration
-
-Business-as-Code enables rapid experimentation directly within your operational framework. Test hypotheses, measure results, and iterate on your strategies and processes using code.
+### 2. Human-AI collaboration points
 
 ```typescript
-import { Business, Experiment, Workflow } from 'business-as-code' // Assuming Workflow is exported here or import from 'workflows.do'
-
-const experimentalBusiness = Business({
-  name: 'GrowthHackers Inc.',
-  vision: '...',
-  objectives: {
-    userAcquisition: {
-      description: 'Maximize new user signups',
-      keyResults: ['Increase weekly signups by 20% in Q3']
-    }
-  },
-  // ... other definitions
+// AI can suggest changes that require human approval
+company.on('content_suggestion', (suggestion, approver) => {
+  // Request approval from human
+  approver.requestApproval(suggestion)
 })
-
-// Define an experiment to test different onboarding flows
-const onboardingExperiment = Experiment({
-  name: 'Onboarding Flow Test',
-  hypothesis: 'A simplified onboarding flow will increase signup conversion rate.',
-  variants: {
-    control: { // Current implementation (defined elsewhere or implicitly handled)
-      workflow: 'standardOnboardingWorkflow' 
-    },
-    simplified: { // New variant defined imperatively
-      workflow: Workflow({
-        name: 'SimplifiedOnboarding',
-        onUserVisit: async ({ ai, api, event }) => {
-          // Minimal steps for quick signup
-          const { email } = event
-          await api.auth.createAccount({ email })
-          await api.sendgrid.sendEmail({ to: email, template: 'quick_welcome' })
-          // ... fewer steps than control
-        }
-      })
-    }
-  },
-  metrics: ['signupConversionRate', 'timeToSignup'],
-  trafficSplit: { control: 0.5, simplified: 0.5 },
-  targetObjective: experimentalBusiness.objectives.userAcquisition, 
-})
-
-// Add the experiment to the business definition
-experimentalBusiness.addExperiment(onboardingExperiment)
-
-// Launch the business with the experiment running
-await experimentalBusiness.launch()
-
-// Later, analyze results (assuming analysis functions exist)
-// const results = await experimentalBusiness.analyzeExperiment('Onboarding Flow Test')
-// console.log(results) 
 ```
 
-## Real-World Examples
-
-Here's a comprehensive example demonstrating how to define a SaaS business using the `business-as-code` framework:
+### 3. Task assignment
 
 ```typescript
-import { Business, Workflow, Agent, Function } from 'business-as-code' // Assuming all primitives are exported
-import { Database } from 'database.do' // Assuming Database comes from database.do
-import { API } from 'apis.do' // Assuming API comes from apis.do
-
-// Define core business logic components first (Workflows, Agents, Functions)
-
-// Example: Lead Generation Workflow
-const leadGeneration = Workflow({
-  name: 'LeadGeneration',
-  onWebsiteVisit: async ({ ai, api, db, event }) => {
-    const { visitorId, pageUrl } = event
-    // Track visit
-    await db.events.log({ type: 'website_visit', visitorId, pageUrl })
-    
-    // If visitor shows interest (e.g., downloads whitepaper)
-    if (event.action === 'download_whitepaper') {
-      const leadData = await api.hubspot.findContact({ email: event.email }) // Use Integrations.do
-      if (!leadData) {
-        await api.hubspot.createContact({ email: event.email, name: event.name })
-        await api.slack.postMessage({ channel: '#leads', content: `New lead: ${event.name} (${event.email})`})
-      }
-    }
-  }
-})
-
-// Example: Customer Support Agent
-const supportAgent = Agent({
-  name: 'SupportAgent',
-  goal: 'Resolve customer support tickets efficiently and effectively',
-  keyResults: [
-    'Maintain average first response time under 1 hour',
-    'Achieve customer satisfaction score (CSAT) of 90%+'
-  ],
-  onTicketReceived: async ({ ai, api, db, ticket }) => {
-    // Analyze ticket content
-    const analysis = await ai.analyzeSupportTicket({ content: ticket.description })
-    
-    // Find relevant documentation using Functions.do
-    const relevantDocs = await ai.findRelevantDocs({ query: analysis.topic })
-    
-    // Draft response
-    const draftResponse = await ai.draftSupportResponse({ 
-      query: ticket.description, 
-      context: relevantDocs 
-    })
-    
-    // Post response (or assign to human if needed)
-    await api.zendesk.updateTicket({ id: ticket.id, comment: draftResponse.content })
+// Assign tasks based on nature and complexity
+function assignTask(task) {
+  if (task.requiresCreativity) {
+    company.assign(task, company.roles.humanCreative)
+  } else if (task.isRepetitive) {
+    company.assign(task, company.agents.automationAgent)
   }
-})
+}
+```
 
-// Define the complete SaaS business
-const saasCompany = Business({
-  name: 'DataInsights',
-  vision: 'Make data analytics accessible to non-technical teams',
-  
-  objectives: {
-    growth: {
-      description: 'Achieve market leadership in SMB analytics',
-      keyResults: [
-        'Acquire 1000 paying customers by end of year',
-        'Reach $1M ARR within 18 months',
-      ]
-    },
-    product: {
-      description: 'Deliver an intuitive and powerful analytics platform',
-      keyResults: [
-        'Achieve a Net Promoter Score (NPS) of 50+',
-        'Reduce onboarding time to under 30 minutes',
-      ]
-    }
-  },
-  
-  // Integrate defined workflows
-  workflows: {
-    leadGeneration,
-    customerOnboarding, // Reuse from earlier example
-    // Add billing, feature-request workflows etc.
-  },
-  
-  // Integrate defined agents
-  agents: {
-    supportAgent,
-    // Add sales outreach agent, data analysis agent etc.
-  },
-  
-  // Define the core data model using Database.do concepts
-  dataModel: {
-    users: Database.collection({ /* ... schema ... */ }),
-    organizations: Database.collection({ /* ... schema ... */ }),
-    datasets: Database.collection({ /* ... schema ... */ }),
-    reports: Database.collection({ /* ... schema ... */ }),
-    // Define relationships, indexes etc.
-  },
+### 4. Event handling differences
 
-  // Define core functions the business relies on
-  functions: {
-    // Example: A function to generate insights from data
-    generateReportInsights: Function({
-      name: 'GenerateReportInsights',
-      input: { reportId: 'string' },
-      output: { insights: 'string[]' },
-      run: async ({ input, ai, db }) => {
-        const reportData = await db.reports.find({ id: input.reportId })
-        // Complex AI logic to derive insights...
-        const insights = await ai.analyzeDataAndGenerateInsights({ data: reportData })
-        return { insights }
-      }
-    })
-    // Add other core business functions
+```typescript
+// Human events may require notifications
+company.on('urgent_issue', (issue) => {
+  if (issue.assignee instanceof Human) {
+    sendNotification(issue.assignee)
+  } else {
+    // AI can handle immediately
+    issue.assignee.handle(issue)
   }
 })
-
-// Launch the business operations
-await saasCompany.launch()
-
-console.log(`Business '${saasCompany.name}' launched successfully.`) // Note: Backticks are fine for template literals
 ```
 
-## Getting Started
+### 5. Permission workflows
 
-### Installation
+```typescript
+// AI can draft but needs human approval for publishing
+company.agents.contentWriter.setPermission('content.publish', 'suggest')
+company.roles.contentManager.setPermission('content.publish', 'approve')
+```
 
-To install the `business-as-code` package, use your preferred package manager:
+### 6. System integration
 
-```bash
-pnpm add business-as-code # Using pnpm (recommended for this monorepo)
-# or
-npm install business-as-code
-# or
-yarn add business-as-code
+```typescript
+// Connect with existing organizational systems
+company.integrate('crm', {
+  endpoint: 'https://crm.company.com/api',
+  handlers: {
+    // Map events between systems
+    'crm:new_customer': (data) => company.trigger('new_customer', data),
+  },
+})
 ```
 
-### Basic Usage
-
-1.  **Import necessary components**: Start by importing `Business` and other primitives like `Workflow`, `Agent`, or `Function` as needed.
-2.  **Define your Business**: Use the `Business()` constructor, providing a name, vision, and objectives.
-3.  **Codify Components**: Define your core workflows, agents, data models, and functions using the respective primitives.
-4.  **Integrate Components**: Add your defined workflows, agents, etc., into the `Business` definition.
-5.  **Launch**: Call the `.launch()` method on your business instance to start its operations.
+### 7. Role guidelines
 
 ```typescript
-import { Business } from 'business-as-code'
+// Define when to use humans vs AI
+const roleGuidelines = {
+  customer_complaints: {
+    simple: company.agents.customerSupport,
+    complex: company.roles.customerSuccessManager,
+    criteria: (complaint) => (complaint.sentiment < -0.8 ? 'complex' : 'simple'),
+  },
+}
+```
 
-// 1. Define the business high-level goals
-const mySimpleBusiness = Business({
-  name: 'My First Coded Business',
-  vision: 'To automate simple tasks',
-  objectives: {
-    taskAutomation: {
-      description: 'Automate one repetitive task this quarter',
-      keyResults: ['Successfully automate task X by end of Q3']
-    }
-  }
-  // Add simple workflows or functions if needed
-})
+## API Reference
 
-// 2. Launch the business
-async function start() {
-  await mySimpleBusiness.launch()
-  console.log('Business launched!')
-}
+### Functions
 
-start()
-```
+- `Business(config)` - Creates a new business representation
 
-This basic structure provides the starting point for building more complex, fully codified businesses. Explore the examples above and the documentation for individual primitives ([Functions](/docs/functions), [Workflows](/docs/workflows), [Agents](/docs/agents)) to learn more.
+### Types
 
-## License
+- `BusinessConfig` - Configuration for creating a business
+- `BusinessInstance` - Instance returned by the Business function
+- `PermissionLevel` - Enum for permission levels (VIEW, SUGGEST, EXECUTE, APPROVE, ADMIN)
+- `Task` - Interface for task assignments
+- `BusinessEvent` - Interface for business events
 
-MIT
+### Business Instance Methods
 
-## Foundational Primitives
+- `on(event, handler)` - Register event handler
+- `every(schedule, operation)` - Register scheduled operation
+- `assign(task, to)` - Assign a task to a human or AI
+- `track(metric, value)` - Track business metrics
 
-Business-as-Code builds upon and orchestrates the core primitives of the [.do](https://dotdo.ai) ecosystem:
+## Dependencies
 
-- [apis.do](https://www.npmjs.com/package/apis.do) - The foundational SDK for all integrations.
-- [functions.do](https://www.npmjs.com/package/functions.do) - AI-powered Functions-as-a-Service.
-- [workflows.do](https://www.npmjs.com/package/workflows.do) - Elegant business process orchestration.
-- [agents.do](https://www.npmjs.com/package/agents.do) - Autonomous AI workers.
-- [database.do](https://www.npmjs.com/package/database.do) - AI Native Data Access.
-- Other `.do` services as needed (Events, Analytics, etc.)
+- [agents.do](https://github.com/drivly/agents.do) - Agent framework for AI operations
+- [humans.do](https://github.com/drivly/humans.do) - Human role definitions and interactions
+- [workflows.do](https://github.com/drivly/workflows.do) - Workflow definitions for business processes

package/TODO.md

@@ -0,0 +1,32 @@
+# business-as-code Implementation TODO
+
+## Current Implementation Status
+
+- [x] Created package structure
+- [x] Implemented package.json with basic configuration
+- [x] Implemented tsup.config.ts for build configuration
+- [x] Implemented tsconfig.json
+- [x] Created types.ts with BusinessConfig interface
+- [x] Implemented Business function in index.ts
+- [x] Created comprehensive README.md
+- [ ] Implement actual dependencies for human-AI collaboration
+- [ ] Test integration with other packages
+
+## Technical Challenges and Blockers
+
+- The package currently uses placeholder types for `Agent`, `Human`, and `Workflow` since the actual dependencies (`agents.do`, `humans.do`, `workflows.do`) don't exist yet
+- Need to implement or find suitable replacements for these dependencies
+- The Business function implementation is a proof of concept and needs to be expanded with actual functionality
+
+## Verification Requirements
+
+- Ensure the package builds correctly
+- Verify TypeScript types are generated correctly
+- Test integration with other packages when dependencies are available
+
+## Next Steps
+
+- Replace placeholder types with actual implementations when dependencies are available
+- Expand the Business function with more comprehensive features
+- Add tests for the Business function
+- Integrate with existing systems and workflows

package/package.json

@@ -1,56 +1,49 @@
 {
   "name": "business-as-code",
-  "version": "0.0.2",
-  "description": "Define, launch, experiment, iterate, and grow your business entirely in code.",
-  "keywords": [
-    "ai",
-    "business",
-    "strategy",
-    "operations",
-    "automation",
-    "sdk",
-    "typescript"
-  ],
-  "homepage": "https://business-as-code.dev",
-  "type": "module",
+  "version": "0.1.0",
+  "description": "Define, launch, experiment, iterate, and grow your business entirely in code",
   "main": "dist/index.js",
-  "module": "dist/index.js",
+  "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
     }
   },
-  "files": [
-    "dist",
-    "README.md"
-  ],
+  "dependencies": {
+    "zod": "^3.24.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.13.10",
+    "esbuild": "^0.25.2",
+    "eslint": "^9.17.0",
+    "prettier": "^3.4.2",
+    "typescript": "^5.8.2",
+    "tsup": "^8.4.0"
+  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/drivly/ai.git",
-    "directory": "pkgs/business-as-code"
+    "url": "https://github.com/drivly/primitives.org.ai.git"
   },
-  "author": "Drivly",
-  "license": "MIT",
+  "homepage": "https://mdx.org.ai",
   "bugs": {
-    "url": "https://github.com/drivly/ai/issues"
+    "url": "https://github.com/drivly/primitives.org.ai/issues"
   },
+  "keywords": [
+    "ai",
+    "business",
+    "human-ai-collaboration",
+    "organization",
+    "processes",
+    "departments",
+    "roles"
+  ],
+  "license": "MIT",
   "scripts": {
-    "build": "tsup src/index.ts --format esm --dts",
-    "dev": "tsup src/index.ts --format esm --dts --watch",
-    "lint": "eslint \"src/**/*.ts*\"",
-    "clean": "rimraf .turbo node_modules dist",
-    "test": "vitest run",
-    "test:watch": "vitest"
-  },
-  "engines": {
-    "node": ">=18.0.0"
-  },
-  "dependencies": {
-    "apis.do": "0.0.1",
-    "database.do": "0.0.1",
-    "functions.do": "0.0.1",
-    "workflows.do": "0.0.1"
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "format": "prettier --write ."
   }
-}
+}

package/src/index.ts

@@ -0,0 +1,77 @@
+import { Agent, Human, Workflow } from './types'
+import { BusinessConfig, BusinessInstance, PermissionLevel, Task, BusinessEvent } from './types'
+
+export { Agent, Human, Workflow }
+export type { BusinessConfig, BusinessInstance, PermissionLevel, Task, BusinessEvent }
+
+/**
+ * Creates a business representation for human-AI collaboration
+ *
+ * @param config The business configuration
+ * @returns A business instance with methods for event handling, scheduling, and task management
+ */
+export function Business(config: BusinessConfig): BusinessInstance {
+  const eventHandlers: Record<string, Function[]> = {}
+
+  const scheduledOperations: Record<string, Function[]> = {}
+
+  const tasks: Task[] = []
+
+  const metrics: Record<string, any[]> = {}
+
+  const business: BusinessInstance = {
+    ...config,
+
+    on: (event: string, handler: Function) => {
+      if (!eventHandlers[event]) {
+        eventHandlers[event] = []
+      }
+      eventHandlers[event].push(handler)
+
+      return business // For chaining
+    },
+
+    every: (schedule: string, operation: Function) => {
+      if (!scheduledOperations[schedule]) {
+        scheduledOperations[schedule] = []
+      }
+      scheduledOperations[schedule].push(operation)
+
+      return business // For chaining
+    },
+
+    assign: (taskTitle: string, to: Human | Agent) => {
+      const task: Task = {
+        id: `task_${Date.now()}`,
+        title: taskTitle,
+        assignee: to,
+        status: 'pending',
+        timestamp: new Date(),
+      }
+
+      tasks.push(task)
+
+      if (to instanceof Agent) {
+        task.status = 'in_progress'
+      } else {
+      }
+
+      return task // Return task for reference
+    },
+
+    track: (metric: string, value: any) => {
+      if (!metrics[metric]) {
+        metrics[metric] = []
+      }
+
+      metrics[metric].push({
+        value,
+        timestamp: new Date(),
+      })
+
+      return business // For chaining
+    },
+  }
+
+  return business
+}

package/src/types.ts

@@ -0,0 +1,97 @@
+export class Agent {}
+export class Human {}
+export class Workflow {}
+
+/**
+ * Business configuration interface
+ */
+export interface BusinessConfig {
+  name: string
+  url?: string
+  vision?: string
+  goals?: Array<{
+    objective: string
+    keyResults?: string[]
+  }>
+  roles?: Record<string, Human>
+  agents?: Record<string, Agent>
+  departments?: Record<
+    string,
+    {
+      name: string
+      lead: Human | Agent
+      members?: Array<Human | Agent>
+    }
+  >
+  processes?: Record<string, Workflow>
+}
+
+/**
+ * Business instance returned by the Business function
+ */
+export interface BusinessInstance {
+  name: string
+  url?: string
+  vision?: string
+  goals?: Array<{
+    objective: string
+    keyResults?: string[]
+  }>
+  roles?: Record<string, Human>
+  agents?: Record<string, Agent>
+  departments?: Record<
+    string,
+    {
+      name: string
+      lead: Human | Agent
+      members?: Array<Human | Agent>
+    }
+  >
+  processes?: Record<string, Workflow>
+
+  on: (event: string, handler: Function) => void
+
+  every: (schedule: string, operation: Function) => void
+
+  assign: (task: string, to: Human | Agent) => void
+
+  track: (metric: string, value: any) => void
+}
+
+/**
+ * Permission level enum for human-AI collaboration
+ */
+export enum PermissionLevel {
+  VIEW = 'view',
+  SUGGEST = 'suggest',
+  EXECUTE = 'execute',
+  APPROVE = 'approve',
+  ADMIN = 'admin',
+}
+
+/**
+ * Task assignment interface
+ */
+export interface Task {
+  id: string
+  title: string
+  description?: string
+  assignee?: Human | Agent
+  dueDate?: Date
+  status?: 'pending' | 'in_progress' | 'completed' | 'blocked'
+  priority?: 'low' | 'medium' | 'high' | 'critical'
+  requiredPermission?: PermissionLevel
+  dependencies?: string[]
+  timestamp?: Date
+}
+
+/**
+ * Event interface for business events
+ */
+export interface BusinessEvent {
+  type: string
+  data: any
+  source?: string
+  timestamp: Date
+  requiredApproval?: Human[]
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "declaration": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "dist"
+  },
+  "include": ["src"]
+}

package/tsup.config.ts

@@ -0,0 +1,12 @@
+export default {
+  entry: {
+    index: 'src/index.ts',
+  },
+  format: ['esm', 'cjs'],
+  dts: true,
+  clean: true,
+  outExtension: ({ format }: { format: string }) => ({
+    js: format === 'cjs' ? '.js' : '.mjs',
+  }),
+  tsconfig: './tsconfig.json',
+}

package/dist/index.d.ts

@@ -1,146 +0,0 @@
-interface BusinessInterface {
-    name: string;
-    vision: string;
-    objectives: Record<string, Objective>;
-    workflows?: Record<string, Workflow>;
-    agents?: Record<string, Agent>;
-    businessModel?: BusinessModel;
-    execute(): Promise<void>;
-    launch(): Promise<void>;
-    addExperiment(experiment: ExperimentInterface): void;
-}
-interface Objective {
-    description: string;
-    keyResults: string[] | KeyResult[];
-}
-interface KeyResult {
-    description: string;
-    target?: number;
-    currentValue?: number;
-    unit?: string;
-    dueDate?: Date;
-}
-interface ExperimentInterface {
-    name: string;
-    hypothesis: string;
-    variants: Record<string, ExperimentVariant>;
-    metrics: string[];
-    trafficSplit: Record<string, number>;
-    targetObjective?: Objective;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    analyze(): Promise<ExperimentResults>;
-}
-interface ExperimentVariant {
-    workflow?: Workflow | string;
-    agent?: Agent | string;
-    function?: Function | string;
-    configuration?: Record<string, any>;
-}
-interface ExperimentResults {
-    variantPerformance: Record<string, VariantPerformance>;
-    winner?: string;
-    confidence?: number;
-    insights: string[];
-}
-interface VariantPerformance {
-    metrics: Record<string, number>;
-    sampleSize: number;
-}
-interface BusinessModel {
-    leanCanvas?: LeanCanvasModel;
-    storyBrand?: StoryBrandModel;
-    valueProposition?: ValuePropositionModel;
-    revenueStreams?: RevenueStream[];
-    customerSegments?: CustomerSegment[];
-}
-interface LeanCanvasModel {
-    problem: string[];
-    solution: string[];
-    uniqueValueProposition: string;
-    unfairAdvantage?: string;
-    customerSegments: string[];
-    keyMetrics: string[];
-    channels: string[];
-    costStructure: string[];
-    revenueStreams: string[];
-}
-interface StoryBrandModel {
-    hero: string;
-    problem: string;
-    guide: string;
-    plan: string[];
-    callToAction: string;
-    failure: string;
-    success: string;
-}
-interface ValuePropositionModel {
-    customerJobs: string[];
-    pains: string[];
-    gains: string[];
-    products: string[];
-    painRelievers: string[];
-    gainCreators: string[];
-}
-interface RevenueStream {
-    name: string;
-    type: 'subscription' | 'transactional' | 'service' | 'product' | 'other';
-    pricingModel: string;
-    estimatedRevenue?: number;
-}
-interface CustomerSegment {
-    name: string;
-    description: string;
-    needs: string[];
-    demographics?: Record<string, string>;
-    behaviors?: string[];
-}
-interface Workflow {
-    name: string;
-    steps: WorkflowStep[];
-    execute(input?: any): Promise<any>;
-}
-interface WorkflowStep {
-    name: string;
-    function?: Function | string;
-    agent?: Agent | string;
-    input?: Record<string, any> | ((context: any) => any);
-    condition?: (context: any) => boolean;
-    onSuccess?: WorkflowStep | string;
-    onError?: WorkflowStep | string;
-}
-interface Function {
-    name: string;
-    execute(input?: any): Promise<any>;
-}
-interface Agent {
-    name: string;
-    execute(task: string, context?: any): Promise<any>;
-}
-
-/**
- * Creates a new Business instance
- */
-declare function Business(config: Omit<BusinessInterface, 'execute' | 'launch' | 'addExperiment'>): BusinessInterface;
-
-/**
- * Creates a new Experiment instance
- */
-declare function Experiment(config: Omit<ExperimentInterface, 'start' | 'stop' | 'analyze'>): ExperimentInterface;
-
-/**
- * Creates a new LeanCanvas instance
- */
-declare function LeanCanvas(config: LeanCanvasModel): LeanCanvasModel;
-
-/**
- * Creates a new StoryBrand instance
- */
-declare function StoryBrand(config: StoryBrandModel): StoryBrandModel;
-
-/**
- * Creates a new ValueProposition instance
- */
-declare function ValueProposition(config: ValuePropositionModel): ValuePropositionModel;
-
-export { type Agent, Business, type BusinessInterface, type BusinessModel, type CustomerSegment, Experiment, type ExperimentInterface, type ExperimentResults, type ExperimentVariant, type Function, type KeyResult, LeanCanvas, type Objective, type RevenueStream, StoryBrand, ValueProposition, type VariantPerformance, type Workflow, type WorkflowStep };

package/dist/index.js

@@ -1,172 +0,0 @@
-// src/business.ts
-function Business(config) {
-  const experiments = [];
-  const state = {
-    isLaunched: false,
-    isExecuting: false,
-    metrics: {}
-  };
-  const business = {
-    ...config,
-    addExperiment(experiment) {
-      experiments.push(experiment);
-    },
-    async launch() {
-      if (state.isLaunched) {
-        return;
-      }
-      if (business.workflows) {
-        for (const workflowKey in business.workflows) {
-          const workflow = business.workflows[workflowKey];
-        }
-      }
-      if (business.agents) {
-        for (const agentKey in business.agents) {
-          const agent = business.agents[agentKey];
-        }
-      }
-      state.isLaunched = true;
-    },
-    async execute() {
-      if (state.isExecuting) {
-        return;
-      }
-      if (!state.isLaunched) {
-        await business.launch();
-      }
-      state.isExecuting = true;
-      try {
-        if (business.workflows) {
-          for (const workflowKey in business.workflows) {
-            const workflow = business.workflows[workflowKey];
-            await workflow.execute();
-          }
-        }
-        for (const experiment of experiments) {
-          await experiment.start();
-        }
-      } finally {
-        state.isExecuting = false;
-      }
-    }
-  };
-  return business;
-}
-
-// src/experiment.ts
-function Experiment(config) {
-  const state = {
-    isRunning: false,
-    startTime: null,
-    endTime: null,
-    variantData: {}
-  };
-  for (const variantKey in config.variants) {
-    state.variantData[variantKey] = {
-      metrics: config.metrics.reduce((acc, metric) => {
-        acc[metric] = [];
-        return acc;
-      }, {}),
-      sampleCount: 0
-    };
-  }
-  const experiment = {
-    ...config,
-    async start() {
-      if (state.isRunning) {
-        return;
-      }
-      state.isRunning = true;
-      state.startTime = /* @__PURE__ */ new Date();
-      for (const variantKey in experiment.variants) {
-        const variant = experiment.variants[variantKey];
-        if (typeof variant.workflow === "string") {
-        }
-        if (typeof variant.agent === "string") {
-        }
-        if (typeof variant.function === "string") {
-        }
-      }
-    },
-    async stop() {
-      if (!state.isRunning) {
-        return;
-      }
-      state.isRunning = false;
-      state.endTime = /* @__PURE__ */ new Date();
-    },
-    async analyze() {
-      if (state.isRunning) {
-        await experiment.stop();
-      }
-      const variantPerformance = {};
-      for (const variantKey in state.variantData) {
-        const variantData = state.variantData[variantKey];
-        const metrics = {};
-        for (const metricKey in variantData.metrics) {
-          const values = variantData.metrics[metricKey];
-          if (values.length > 0) {
-            metrics[metricKey] = values.reduce((sum, value) => sum + value, 0) / values.length;
-          } else {
-            metrics[metricKey] = 0;
-          }
-        }
-        variantPerformance[variantKey] = {
-          metrics,
-          sampleSize: variantData.sampleCount
-        };
-      }
-      let winner;
-      let highestScore = -Infinity;
-      const primaryMetric = experiment.metrics[0];
-      for (const variantKey in variantPerformance) {
-        const performance = variantPerformance[variantKey];
-        const score = performance.metrics[primaryMetric] || 0;
-        if (score > highestScore) {
-          highestScore = score;
-          winner = variantKey;
-        }
-      }
-      const insights = [
-        `Experiment ran for ${state.startTime && state.endTime ? Math.round((state.endTime.getTime() - state.startTime.getTime()) / (1e3 * 60 * 60 * 24)) : "unknown"} days`,
-        winner ? `Variant "${winner}" performed best on primary metric "${primaryMetric}"` : "No clear winner determined"
-      ];
-      return {
-        variantPerformance,
-        winner,
-        confidence: 0.95,
-        // Placeholder - would calculate actual confidence in real implementation
-        insights
-      };
-    }
-  };
-  return experiment;
-}
-
-// src/models/lean-canvas.ts
-function LeanCanvas(config) {
-  return {
-    ...config
-  };
-}
-
-// src/models/story-brand.ts
-function StoryBrand(config) {
-  return {
-    ...config
-  };
-}
-
-// src/models/value-proposition.ts
-function ValueProposition(config) {
-  return {
-    ...config
-  };
-}
-export {
-  Business,
-  Experiment,
-  LeanCanvas,
-  StoryBrand,
-  ValueProposition
-};