business-as-code 0.2.1 → 2.0.2

package/src/process.ts

@@ -0,0 +1,272 @@
+/**
+ * Business process definition and management
+ */
+
+import type { ProcessDefinition, ProcessStep, ProcessMetric } from './types.js'
+
+/**
+ * Define a business process with steps, inputs, outputs, and metrics
+ *
+ * @example
+ * ```ts
+ * const process = Process({
+ *   name: 'Customer Onboarding',
+ *   description: 'Process for onboarding new customers',
+ *   category: 'core',
+ *   owner: 'Customer Success Team',
+ *   steps: [
+ *     {
+ *       order: 1,
+ *       name: 'Welcome Email',
+ *       description: 'Send personalized welcome email',
+ *       responsible: 'CS Manager',
+ *       duration: '5 minutes',
+ *       automationLevel: 'automated',
+ *     },
+ *     {
+ *       order: 2,
+ *       name: 'Initial Setup Call',
+ *       description: 'Schedule and conduct setup call',
+ *       responsible: 'CS Rep',
+ *       duration: '30 minutes',
+ *       automationLevel: 'manual',
+ *     },
+ *     {
+ *       order: 3,
+ *       name: 'Account Configuration',
+ *       description: 'Configure customer account settings',
+ *       responsible: 'CS Rep',
+ *       duration: '15 minutes',
+ *       automationLevel: 'semi-automated',
+ *     },
+ *   ],
+ *   inputs: ['Customer Information', 'Subscription Plan'],
+ *   outputs: ['Configured Account', 'Training Materials'],
+ *   metrics: [
+ *     {
+ *       name: 'Time to First Value',
+ *       description: 'Time from signup to first successful use',
+ *       target: 24,
+ *       unit: 'hours',
+ *     },
+ *     {
+ *       name: 'Onboarding Completion Rate',
+ *       description: 'Percentage of customers completing onboarding',
+ *       target: 90,
+ *       unit: 'percent',
+ *     },
+ *   ],
+ * })
+ * ```
+ */
+export function Process(definition: ProcessDefinition): ProcessDefinition {
+  if (!definition.name) {
+    throw new Error('Process name is required')
+  }
+
+  return {
+    ...definition,
+    category: definition.category || 'support',
+    steps: definition.steps || [],
+    inputs: definition.inputs || [],
+    outputs: definition.outputs || [],
+    metrics: definition.metrics || [],
+    metadata: definition.metadata || {},
+  }
+}
+
+/**
+ * Get process steps in order
+ */
+export function getStepsInOrder(process: ProcessDefinition): ProcessStep[] {
+  return [...(process.steps || [])].sort((a, b) => a.order - b.order)
+}
+
+/**
+ * Get steps by automation level
+ */
+export function getStepsByAutomationLevel(
+  process: ProcessDefinition,
+  level: ProcessStep['automationLevel']
+): ProcessStep[] {
+  return process.steps?.filter(step => step.automationLevel === level) || []
+}
+
+/**
+ * Calculate total process duration in minutes
+ */
+export function calculateTotalDuration(process: ProcessDefinition): number {
+  return (
+    process.steps?.reduce((total, step) => {
+      return total + parseDurationToMinutes(step.duration)
+    }, 0) || 0
+  )
+}
+
+/**
+ * Parse duration string to minutes
+ */
+function parseDurationToMinutes(duration?: string): number {
+  if (!duration) return 0
+
+  const lower = duration.toLowerCase()
+  const match = lower.match(/(\d+)\s*(minute|minutes|min|hour|hours|hr|day|days|week|weeks)/)
+  if (!match) return 0
+
+  const value = parseInt(match[1] || '0', 10)
+  const unit = match[2]
+
+  switch (unit) {
+    case 'minute':
+    case 'minutes':
+    case 'min':
+      return value
+    case 'hour':
+    case 'hours':
+    case 'hr':
+      return value * 60
+    case 'day':
+    case 'days':
+      return value * 60 * 24
+    case 'week':
+    case 'weeks':
+      return value * 60 * 24 * 7
+    default:
+      return 0
+  }
+}
+
+/**
+ * Format minutes to human-readable duration
+ */
+export function formatDuration(minutes: number): string {
+  if (minutes < 60) {
+    return `${minutes} minutes`
+  } else if (minutes < 60 * 24) {
+    const hours = Math.floor(minutes / 60)
+    const mins = minutes % 60
+    return mins > 0 ? `${hours} hours ${mins} minutes` : `${hours} hours`
+  } else {
+    const days = Math.floor(minutes / (60 * 24))
+    const hours = Math.floor((minutes % (60 * 24)) / 60)
+    return hours > 0 ? `${days} days ${hours} hours` : `${days} days`
+  }
+}
+
+/**
+ * Calculate automation percentage
+ */
+export function calculateAutomationPercentage(process: ProcessDefinition): number {
+  if (!process.steps || process.steps.length === 0) return 0
+
+  const automatedSteps = process.steps.filter(
+    step => step.automationLevel === 'automated' || step.automationLevel === 'semi-automated'
+  ).length
+
+  return (automatedSteps / process.steps.length) * 100
+}
+
+/**
+ * Get metric by name
+ */
+export function getMetric(process: ProcessDefinition, name: string): ProcessMetric | undefined {
+  return process.metrics?.find(m => m.name === name)
+}
+
+/**
+ * Check if metric meets target
+ */
+export function meetsTarget(metric: ProcessMetric): boolean {
+  if (metric.target === undefined || metric.current === undefined) return false
+  return metric.current >= metric.target
+}
+
+/**
+ * Calculate metric achievement percentage
+ */
+export function calculateMetricAchievement(metric: ProcessMetric): number {
+  if (metric.target === undefined || metric.current === undefined) return 0
+  if (metric.target === 0) return 100
+  return (metric.current / metric.target) * 100
+}
+
+/**
+ * Update metric current value
+ */
+export function updateMetric(
+  process: ProcessDefinition,
+  metricName: string,
+  currentValue: number
+): ProcessDefinition {
+  const metrics = process.metrics?.map(m =>
+    m.name === metricName ? { ...m, current: currentValue } : m
+  )
+
+  return {
+    ...process,
+    metrics,
+  }
+}
+
+/**
+ * Add step to process
+ */
+export function addStep(process: ProcessDefinition, step: ProcessStep): ProcessDefinition {
+  return {
+    ...process,
+    steps: [...(process.steps || []), step],
+  }
+}
+
+/**
+ * Remove step from process
+ */
+export function removeStep(process: ProcessDefinition, stepOrder: number): ProcessDefinition {
+  return {
+    ...process,
+    steps: process.steps?.filter(s => s.order !== stepOrder),
+  }
+}
+
+/**
+ * Validate process definition
+ */
+export function validateProcess(process: ProcessDefinition): { valid: boolean; errors: string[] } {
+  const errors: string[] = []
+
+  if (!process.name) {
+    errors.push('Process name is required')
+  }
+
+  if (process.steps) {
+    const orders = new Set<number>()
+    for (const step of process.steps) {
+      if (!step.name) {
+        errors.push(`Step at order ${step.order} must have a name`)
+      }
+      if (orders.has(step.order)) {
+        errors.push(`Duplicate step order: ${step.order}`)
+      }
+      orders.add(step.order)
+    }
+  }
+
+  if (process.metrics) {
+    for (const metric of process.metrics) {
+      if (!metric.name) {
+        errors.push('Metric must have a name')
+      }
+      if (metric.target !== undefined && metric.target < 0) {
+        errors.push(`Metric ${metric.name} target cannot be negative`)
+      }
+      if (metric.current !== undefined && metric.current < 0) {
+        errors.push(`Metric ${metric.name} current value cannot be negative`)
+      }
+    }
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  }
+}

package/src/product.ts

@@ -0,0 +1,178 @@
+/**
+ * Product definition and management
+ */
+
+import type { ProductDefinition, RoadmapItem } from './types.js'
+
+/**
+ * Define a product with pricing, features, and roadmap
+ *
+ * @example
+ * ```ts
+ * const product = Product({
+ *   name: 'Widget Pro',
+ *   description: 'Enterprise-grade widget management platform',
+ *   category: 'SaaS',
+ *   targetSegment: 'Enterprise',
+ *   valueProposition: 'Reduce widget management costs by 50%',
+ *   pricingModel: 'subscription',
+ *   price: 99,
+ *   currency: 'USD',
+ *   cogs: 20,
+ *   features: [
+ *     'Unlimited widgets',
+ *     'Advanced analytics',
+ *     'API access',
+ *     '24/7 support',
+ *   ],
+ *   roadmap: [
+ *     {
+ *       name: 'Mobile app',
+ *       description: 'Native iOS and Android apps',
+ *       targetDate: new Date('2024-09-01'),
+ *       priority: 'high',
+ *       status: 'in-progress',
+ *     },
+ *     {
+ *       name: 'AI-powered insights',
+ *       description: 'Automated widget optimization suggestions',
+ *       targetDate: new Date('2024-12-01'),
+ *       priority: 'high',
+ *       status: 'planned',
+ *     },
+ *   ],
+ * })
+ * ```
+ */
+export function Product(definition: ProductDefinition): ProductDefinition {
+  if (!definition.name) {
+    throw new Error('Product name is required')
+  }
+
+  return {
+    ...definition,
+    pricingModel: definition.pricingModel || 'one-time',
+    currency: definition.currency || 'USD',
+    features: definition.features || [],
+    roadmap: definition.roadmap || [],
+    metadata: definition.metadata || {},
+  }
+}
+
+/**
+ * Calculate gross margin for a product
+ */
+export function calculateGrossMargin(product: ProductDefinition): number {
+  if (!product.price || !product.cogs) return 0
+  return ((product.price - product.cogs) / product.price) * 100
+}
+
+/**
+ * Calculate gross profit for a product
+ */
+export function calculateGrossProfit(product: ProductDefinition, unitsSold: number): number {
+  if (!product.price || !product.cogs) return 0
+  return (product.price - product.cogs) * unitsSold
+}
+
+/**
+ * Get roadmap items by status
+ */
+export function getRoadmapByStatus(
+  product: ProductDefinition,
+  status: RoadmapItem['status']
+): RoadmapItem[] {
+  return product.roadmap?.filter(item => item.status === status) || []
+}
+
+/**
+ * Get roadmap items by priority
+ */
+export function getRoadmapByPriority(
+  product: ProductDefinition,
+  priority: RoadmapItem['priority']
+): RoadmapItem[] {
+  return product.roadmap?.filter(item => item.priority === priority) || []
+}
+
+/**
+ * Get overdue roadmap items
+ */
+export function getOverdueRoadmapItems(product: ProductDefinition): RoadmapItem[] {
+  const now = new Date()
+  return (
+    product.roadmap?.filter(
+      item =>
+        item.targetDate &&
+        item.targetDate < now &&
+        item.status !== 'completed' &&
+        item.status !== 'cancelled'
+    ) || []
+  )
+}
+
+/**
+ * Update roadmap item status
+ */
+export function updateRoadmapItem(
+  product: ProductDefinition,
+  itemName: string,
+  updates: Partial<RoadmapItem>
+): ProductDefinition {
+  const roadmap = product.roadmap?.map(item =>
+    item.name === itemName ? { ...item, ...updates } : item
+  )
+
+  return {
+    ...product,
+    roadmap,
+  }
+}
+
+/**
+ * Add feature to product
+ */
+export function addFeature(product: ProductDefinition, feature: string): ProductDefinition {
+  return {
+    ...product,
+    features: [...(product.features || []), feature],
+  }
+}
+
+/**
+ * Remove feature from product
+ */
+export function removeFeature(product: ProductDefinition, feature: string): ProductDefinition {
+  return {
+    ...product,
+    features: product.features?.filter(f => f !== feature) || [],
+  }
+}
+
+/**
+ * Validate product definition
+ */
+export function validateProduct(product: ProductDefinition): { valid: boolean; errors: string[] } {
+  const errors: string[] = []
+
+  if (!product.name) {
+    errors.push('Product name is required')
+  }
+
+  if (product.price && product.price < 0) {
+    errors.push('Product price cannot be negative')
+  }
+
+  if (product.cogs && product.cogs < 0) {
+    errors.push('Product COGS cannot be negative')
+  }
+
+  if (product.price && product.cogs && product.cogs > product.price) {
+    errors.push('Product COGS cannot exceed price')
+  }
+
+  return {
+    valid: errors.length === 0,
+    errors,
+  }
+}