business-as-code 2.1.3 → 2.4.0

package/src/okrs.ts

@@ -1,8 +1,106 @@
 /**
  * Objectives and Key Results (OKRs) management
+ *
+ * Uses org.ai OKR types for standardized OKR definitions across the ecosystem.
  */
 
 import type { OKRDefinition, KeyResult } from './types.js'
+import type { OKR as OrgOKR, KeyResult as OrgKeyResult, OKRStatus, KeyResultStatus } from 'org.ai'
+
+// Re-export org.ai OKR types for convenience
+export type { OrgOKR, OrgKeyResult, OKRStatus, KeyResultStatus }
+
+/**
+ * Convert a business-as-code KeyResult to an org.ai KeyResult
+ *
+ * @param kr - Business key result
+ * @param id - Optional identifier
+ * @returns org.ai KeyResult object
+ */
+export function toOrgKeyResult(kr: KeyResult, id?: string): OrgKeyResult {
+  const result: OrgKeyResult = {
+    description: kr.description,
+  }
+  if (id !== undefined) result.id = id
+  if (kr.description) result.name = kr.description
+  if (kr.metric !== undefined) result.metric = kr.metric
+  if (kr.startValue !== undefined) result.startValue = kr.startValue
+  if (kr.targetValue !== undefined) {
+    result.targetValue = kr.targetValue
+    result.target = kr.targetValue
+  }
+  if (kr.currentValue !== undefined) {
+    result.currentValue = kr.currentValue
+    result.current = kr.currentValue
+  }
+  if (kr.unit !== undefined) result.unit = kr.unit
+  if (kr.progress !== undefined) result.progress = kr.progress
+  return result
+}
+
+/**
+ * Convert an org.ai KeyResult to a business-as-code KeyResult
+ *
+ * @param kr - org.ai KeyResult object
+ * @returns Business key result
+ */
+export function fromOrgKeyResult(kr: OrgKeyResult): KeyResult {
+  const result: KeyResult = {
+    description: kr.description || kr.name || '',
+    metric: kr.metric || '',
+    targetValue: kr.targetValue ?? kr.target ?? 0,
+  }
+  if (kr.startValue !== undefined) result.startValue = kr.startValue
+  if (kr.currentValue !== undefined) result.currentValue = kr.currentValue
+  else if (kr.current !== undefined) result.currentValue = kr.current
+  if (kr.unit !== undefined) result.unit = kr.unit
+  if (kr.progress !== undefined) result.progress = kr.progress
+  return result
+}
+
+/**
+ * Convert a business-as-code OKRDefinition to an org.ai OKR
+ *
+ * @param definition - Business OKR definition
+ * @param id - Optional unique identifier
+ * @returns org.ai OKR object
+ */
+export function toOrgOKR(definition: OKRDefinition, id?: string): OrgOKR {
+  const result: OrgOKR = {
+    objective: definition.objective,
+    keyResults: definition.keyResults?.map((kr, i) => toOrgKeyResult(kr, `${id}_kr_${i}`)) || [],
+  }
+  if (id !== undefined) result.id = id
+  if (definition.description !== undefined) result.description = definition.description
+  if (definition.owner !== undefined) result.owner = definition.owner
+  if (definition.period !== undefined) result.period = definition.period
+  if (definition.status !== undefined) result.status = definition.status as OKRStatus
+  result.progress = calculateOKRProgress(definition)
+  if (definition.confidence !== undefined) result.confidence = definition.confidence
+  if (definition.metadata !== undefined) result.metadata = definition.metadata
+  return result
+}
+
+/**
+ * Convert an org.ai OKR to a business-as-code OKRDefinition
+ *
+ * @param okr - org.ai OKR object
+ * @returns Business OKR definition
+ */
+export function fromOrgOKR(okr: OrgOKR): OKRDefinition {
+  const result: OKRDefinition = {
+    objective: okr.objective,
+    keyResults: okr.keyResults.map(fromOrgKeyResult),
+  }
+  if (okr.description !== undefined) result.description = okr.description
+  if (okr.owner !== undefined) result.owner = okr.owner
+  if (okr.period !== undefined) result.period = okr.period
+  const st = okr.status
+  if (st !== undefined) result.status = st as NonNullable<OKRDefinition['status']>
+  if (okr.confidence !== undefined) result.confidence = okr.confidence
+  if (okr.metadata !== undefined) result.metadata = okr.metadata
+  return result
+}
 
 /**
  * Define Objectives and Key Results for goal tracking
@@ -51,7 +149,7 @@ import type { OKRDefinition, KeyResult } from './types.js'
  * ```
  */
 export function okrs(definitions: OKRDefinition[]): OKRDefinition[] {
-  return definitions.map(okr => validateAndNormalizeOKR(okr))
+  return definitions.map((okr) => validateAndNormalizeOKR(okr))
 }
 
 /**
@@ -70,18 +168,19 @@ function validateAndNormalizeOKR(okr: OKRDefinition): OKRDefinition {
   }
 
   // Calculate progress for key results if not set
-  const keyResults = okr.keyResults?.map(kr => ({
+  const keyResults = okr.keyResults?.map((kr) => ({
     ...kr,
     progress: kr.progress ?? calculateKeyResultProgress(kr),
   }))
 
-  return {
+  const result: OKRDefinition = {
     ...okr,
-    keyResults,
     status: okr.status || 'not-started',
     confidence: okr.confidence ?? calculateConfidence(keyResults || []),
     metadata: okr.metadata || {},
   }
+  if (keyResults !== undefined) result.keyResults = keyResults
+  return result
 }
 
 /**
@@ -136,7 +235,7 @@ export function updateKeyResult(
   krDescription: string,
   currentValue: number
 ): OKRDefinition {
-  const keyResults = okr.keyResults?.map(kr => {
+  const keyResults = okr.keyResults?.map((kr) => {
     if (kr.description === krDescription) {
       const updatedKR = { ...kr, currentValue }
       return {
@@ -148,24 +247,24 @@ export function updateKeyResult(
   })
 
   // Recalculate overall status and confidence
-  const progress = calculateOKRProgress({ ...okr, keyResults })
+  const okrWithKeyResults: OKRDefinition = { ...okr }
+  if (keyResults !== undefined) okrWithKeyResults.keyResults = keyResults
+  const progress = calculateOKRProgress(okrWithKeyResults)
   const status = determineOKRStatus(progress, okr.confidence || 0)
 
-  return {
+  const result: OKRDefinition = {
     ...okr,
-    keyResults,
-    status,
     confidence: calculateConfidence(keyResults || []),
   }
+  if (keyResults !== undefined) result.keyResults = keyResults
+  if (status !== undefined) result.status = status
+  return result
 }
 
 /**
  * Determine OKR status based on progress and confidence
  */
-function determineOKRStatus(
-  progress: number,
-  confidence: number
-): OKRDefinition['status'] {
+function determineOKRStatus(progress: number, confidence: number): OKRDefinition['status'] {
   if (progress === 0) return 'not-started'
   if (progress === 100) return 'completed'
   if (confidence < 50 || progress < 30) return 'at-risk'
@@ -199,21 +298,21 @@ export function getKeyResultsOnTrack(okr: OKRDefinition): KeyResult[] {
  * Get key results that are at risk
  */
 export function getKeyResultsAtRisk(okr: OKRDefinition): KeyResult[] {
-  return okr.keyResults?.filter(kr => !isKeyResultOnTrack(kr)) || []
+  return okr.keyResults?.filter((kr) => !isKeyResultOnTrack(kr)) || []
 }
 
 /**
  * Get OKRs by owner
  */
 export function getOKRsByOwner(okrs: OKRDefinition[], owner: string): OKRDefinition[] {
-  return okrs.filter(okr => okr.owner === owner)
+  return okrs.filter((okr) => okr.owner === owner)
 }
 
 /**
  * Get OKRs by period
  */
 export function getOKRsByPeriod(okrs: OKRDefinition[], period: string): OKRDefinition[] {
-  return okrs.filter(okr => okr.period === period)
+  return okrs.filter((okr) => okr.period === period)
 }
 
 /**
@@ -223,7 +322,7 @@ export function getOKRsByStatus(
   okrs: OKRDefinition[],
   status: OKRDefinition['status']
 ): OKRDefinition[] {
-  return okrs.filter(okr => okr.status === status)
+  return okrs.filter((okr) => okr.status === status)
 }
 
 /**
@@ -232,9 +331,10 @@ export function getOKRsByStatus(
 export function calculateSuccessRate(okrs: OKRDefinition[]): number {
   if (okrs.length === 0) return 0
 
-  const avgProgress = okrs.reduce((sum, okr) => {
-    return sum + calculateOKRProgress(okr)
-  }, 0) / okrs.length
+  const avgProgress =
+    okrs.reduce((sum, okr) => {
+      return sum + calculateOKRProgress(okr)
+    }, 0) / okrs.length
 
   return avgProgress
 }

package/src/organization.ts

@@ -741,7 +741,7 @@ export function resolvePermissions(
   // Search through hierarchy
   for (const dept of org.departments || []) {
     for (const t of dept.teams || []) {
-      const pos = t.positions?.find(p => p.id === positionId)
+      const pos = t.positions?.find((p) => p.id === positionId)
       if (pos) {
         position = pos
         team = t
@@ -755,7 +755,7 @@ export function resolvePermissions(
   // Also check standalone teams
   if (!position) {
     for (const t of org.teams || []) {
-      const pos = t.positions?.find(p => p.id === positionId)
+      const pos = t.positions?.find((p) => p.id === positionId)
       if (pos) {
         position = pos
         team = t
@@ -767,7 +767,7 @@ export function resolvePermissions(
   if (!position) return null
 
   // Find the role
-  const role = org.roles?.find(r => r.id === position.roleId)
+  const role = org.roles?.find((r) => r['id'] === position.roleId)
 
   // Build inheritance chain
   const inheritanceChain: string[] = []
@@ -803,16 +803,16 @@ export function resolvePermissions(
 
   // 4. Role permissions
   if (role?.permissions) {
-    inheritanceChain.push(`role:${role.id}`)
+    inheritanceChain.push(`role:${role['id']}`)
     mergePermissions(permissions, role.permissions)
   }
 
   // 5. Role capabilities
-  if (role?.canApprove) {
-    canApprove.push(...role.canApprove)
+  if (role?.['canApprove']) {
+    canApprove.push(...role['canApprove'])
   }
-  if (role?.canHandle) {
-    canHandle.push(...role.canHandle)
+  if (role?.['canHandle']) {
+    canHandle.push(...role['canHandle'])
   }
 
   // 6. Position-specific permissions
@@ -867,7 +867,7 @@ export function getApprovalChainForRequest(
   requestType: string,
   amount?: number
 ): ApproverSpec[] {
-  const chain = org.approvalChains?.find(c => c.type === requestType && c.active !== false)
+  const chain = org.approvalChains?.find((c) => c.type === requestType && c.active !== false)
   if (!chain) return []
 
   // Find the appropriate level based on amount
@@ -886,19 +886,16 @@ export function getApprovalChainForRequest(
 /**
  * Find manager for a position (follows reportsTo chain)
  */
-export function findManager(
-  org: Organization,
-  positionId: string
-): Position | null {
+export function findManager(org: Organization, positionId: string): Position | null {
   // Find the position
   for (const dept of org.departments || []) {
     for (const team of dept.teams || []) {
-      const position = team.positions?.find(p => p.id === positionId)
+      const position = team.positions?.find((p) => p.id === positionId)
       if (position?.reportsTo) {
         // Find the manager position
         for (const d of org.departments || []) {
           for (const t of d.teams || []) {
-            const manager = t.positions?.find(p => p.id === position.reportsTo)
+            const manager = t.positions?.find((p) => p.id === position.reportsTo)
             if (manager) return manager
           }
         }

package/src/process.ts

@@ -89,7 +89,7 @@ export function getStepsByAutomationLevel(
   process: ProcessDefinition,
   level: ProcessStep['automationLevel']
 ): ProcessStep[] {
-  return process.steps?.filter(step => step.automationLevel === level) || []
+  return process.steps?.filter((step) => step.automationLevel === level) || []
 }
 
 /**
@@ -160,7 +160,7 @@ export function calculateAutomationPercentage(process: ProcessDefinition): numbe
   if (!process.steps || process.steps.length === 0) return 0
 
   const automatedSteps = process.steps.filter(
-    step => step.automationLevel === 'automated' || step.automationLevel === 'semi-automated'
+    (step) => step.automationLevel === 'automated' || step.automationLevel === 'semi-automated'
   ).length
 
   return (automatedSteps / process.steps.length) * 100
@@ -170,7 +170,7 @@ export function calculateAutomationPercentage(process: ProcessDefinition): numbe
  * Get metric by name
  */
 export function getMetric(process: ProcessDefinition, name: string): ProcessMetric | undefined {
-  return process.metrics?.find(m => m.name === name)
+  return process.metrics?.find((m) => m.name === name)
 }
 
 /**
@@ -198,14 +198,13 @@ export function updateMetric(
   metricName: string,
   currentValue: number
 ): ProcessDefinition {
-  const metrics = process.metrics?.map(m =>
+  const metrics = process.metrics?.map((m) =>
     m.name === metricName ? { ...m, current: currentValue } : m
   )
 
-  return {
-    ...process,
-    metrics,
-  }
+  const result: ProcessDefinition = { ...process }
+  if (metrics !== undefined) result.metrics = metrics
+  return result
 }
 
 /**
@@ -222,10 +221,10 @@ export function addStep(process: ProcessDefinition, step: ProcessStep): ProcessD
  * Remove step from process
  */
 export function removeStep(process: ProcessDefinition, stepOrder: number): ProcessDefinition {
-  return {
-    ...process,
-    steps: process.steps?.filter(s => s.order !== stepOrder),
-  }
+  const steps = process.steps?.filter((s) => s.order !== stepOrder)
+  const result: ProcessDefinition = { ...process }
+  if (steps !== undefined) result.steps = steps
+  return result
 }
 
 /**

package/src/product.ts

@@ -82,7 +82,7 @@ export function getRoadmapByStatus(
   product: ProductDefinition,
   status: RoadmapItem['status']
 ): RoadmapItem[] {
-  return product.roadmap?.filter(item => item.status === status) || []
+  return product.roadmap?.filter((item) => item.status === status) || []
 }
 
 /**
@@ -92,7 +92,7 @@ export function getRoadmapByPriority(
   product: ProductDefinition,
   priority: RoadmapItem['priority']
 ): RoadmapItem[] {
-  return product.roadmap?.filter(item => item.priority === priority) || []
+  return product.roadmap?.filter((item) => item.priority === priority) || []
 }
 
 /**
@@ -102,7 +102,7 @@ export function getOverdueRoadmapItems(product: ProductDefinition): RoadmapItem[
   const now = new Date()
   return (
     product.roadmap?.filter(
-      item =>
+      (item) =>
         item.targetDate &&
         item.targetDate < now &&
         item.status !== 'completed' &&
@@ -119,14 +119,13 @@ export function updateRoadmapItem(
   itemName: string,
   updates: Partial<RoadmapItem>
 ): ProductDefinition {
-  const roadmap = product.roadmap?.map(item =>
+  const roadmap = product.roadmap?.map((item) =>
     item.name === itemName ? { ...item, ...updates } : item
   )
 
-  return {
-    ...product,
-    roadmap,
-  }
+  const result: ProductDefinition = { ...product }
+  if (roadmap !== undefined) result.roadmap = roadmap
+  return result
 }
 
 /**
@@ -145,7 +144,7 @@ export function addFeature(product: ProductDefinition, feature: string): Product
 export function removeFeature(product: ProductDefinition, feature: string): ProductDefinition {
   return {
     ...product,
-    features: product.features?.filter(f => f !== feature) || [],
+    features: product.features?.filter((f) => f !== feature) || [],
   }
 }