digital-tasks 2.1.1 → 2.3.0

package/src/project.ts

@@ -59,10 +59,7 @@ export type ExecutionMode = 'parallel' | 'sequential'
 /**
  * Task node in a workflow - can be a single task or a group
  */
-export type TaskNode =
-  | TaskDefinition
-  | ParallelGroup
-  | SequentialGroup
+export type TaskNode = TaskDefinition | ParallelGroup | SequentialGroup
 
 /**
  * Function type for the DSL
@@ -107,12 +104,7 @@ export interface SequentialGroup {
 /**
  * Project status
  */
-export type ProjectStatus =
-  | 'draft'
-  | 'active'
-  | 'paused'
-  | 'completed'
-  | 'cancelled'
+export type ProjectStatus = 'draft' | 'active' | 'paused' | 'completed' | 'cancelled'
 
 /**
  * Project definition
@@ -261,19 +253,28 @@ function generateProjectId(): string {
  */
 export function createProject(options: CreateProjectOptions): Project {
   const now = new Date()
-  return {
+  const project: Project = {
     id: generateProjectId(),
     name: options.name,
-    description: options.description,
     status: 'draft',
     tasks: options.tasks || [],
     defaultMode: options.defaultMode || 'sequential',
-    owner: options.owner,
-    tags: options.tags,
     createdAt: now,
     updatedAt: now,
-    metadata: options.metadata,
   }
+  if (options.description !== undefined) {
+    project.description = options.description
+  }
+  if (options.owner !== undefined) {
+    project.owner = options.owner
+  }
+  if (options.tags !== undefined) {
+    project.tags = options.tags
+  }
+  if (options.metadata !== undefined) {
+    project.metadata = options.metadata
+  }
+  return project
 }
 
 // ============================================================================
@@ -325,7 +326,10 @@ export function workflow(name: string, description?: string) {
      */
     then(...nodes: TaskNode[]) {
       if (nodes.length === 1) {
-        tasks.push(nodes[0])
+        const node = nodes[0]
+        if (node !== undefined) {
+          tasks.push(node)
+        }
       } else {
         tasks.push(sequential(...nodes))
       }
@@ -344,12 +348,15 @@ export function workflow(name: string, description?: string) {
      * Build the project
      */
     build(options?: Partial<Omit<CreateProjectOptions, 'name' | 'tasks'>>): Project {
-      return createProject({
+      const projectOptions: CreateProjectOptions = {
         name,
-        description,
         tasks,
         ...options,
-      })
+      }
+      if (description !== undefined) {
+        projectOptions.description = description
+      }
+      return createProject(projectOptions)
     },
   }
 
@@ -380,9 +387,7 @@ export async function materializeProject(
       const taskId = `${project.id}_task_${taskIndex++}`
 
       // Create dependencies based on mode (as string array for CreateTaskOptions)
-      const dependencies = mode === 'sequential' && previousIds.length > 0
-        ? previousIds
-        : undefined
+      const dependencies = mode === 'sequential' && previousIds.length > 0 ? previousIds : undefined
 
       // Create a FunctionDefinition from the task definition
       // Default to generative function type for DSL tasks
@@ -394,19 +399,28 @@ export async function materializeProject(
         output: 'string',
       } as FunctionDefinition
 
-      const newTask = await createBaseTask({
-        function: functionDef,
+      const createTaskOptions: CreateTaskOptions = {
+        tool: functionDef,
         priority: taskDef.priority || 'normal',
-        assignTo: taskDef.assignTo,
-        tags: taskDef.tags,
-        parentId,
         projectId: project.id,
-        dependencies,
         metadata: {
           ...taskDef.metadata,
           _taskNodeIndex: taskIndex - 1,
         },
-      })
+      }
+      if (taskDef.assignTo !== undefined) {
+        createTaskOptions.assignTo = taskDef.assignTo
+      }
+      if (taskDef.tags !== undefined) {
+        createTaskOptions.tags = taskDef.tags
+      }
+      if (parentId !== undefined) {
+        createTaskOptions.parentId = parentId
+      }
+      if (dependencies !== undefined) {
+        createTaskOptions.dependencies = dependencies
+      }
+      const newTask = await createBaseTask(createTaskOptions)
 
       // Override the generated ID with our predictable one
       ;(newTask as AnyTask).id = taskId
@@ -455,7 +469,12 @@ export async function materializeProject(
   // Process all root-level tasks
   let previousIds: string[] = []
   for (const node of project.tasks) {
-    previousIds = await processNode(node, undefined, previousIds, project.defaultMode || 'sequential')
+    previousIds = await processNode(
+      node,
+      undefined,
+      previousIds,
+      project.defaultMode || 'sequential'
+    )
   }
 
   return { project, tasks }
@@ -469,8 +488,8 @@ export async function materializeProject(
  * Get all tasks that depend on a given task (dependants)
  */
 export function getDependants(taskId: string, allTasks: AnyTask[]): AnyTask[] {
-  return allTasks.filter(t =>
-    t.dependencies?.some(d => d.taskId === taskId && d.type === 'blocked_by')
+  return allTasks.filter((t) =>
+    t.dependencies?.some((d) => d.taskId === taskId && d.type === 'blocked_by')
   )
 }
 
@@ -480,25 +499,21 @@ export function getDependants(taskId: string, allTasks: AnyTask[]): AnyTask[] {
 export function getDependencies(task: AnyTask, allTasks: AnyTask[]): AnyTask[] {
   if (!task.dependencies) return []
 
-  const depIds = task.dependencies
-    .filter(d => d.type === 'blocked_by')
-    .map(d => d.taskId)
+  const depIds = task.dependencies.filter((d) => d.type === 'blocked_by').map((d) => d.taskId)
 
-  return allTasks.filter(t => depIds.includes(t.id))
+  return allTasks.filter((t) => depIds.includes(t.id))
 }
 
 /**
  * Get tasks that are ready to execute (no unsatisfied dependencies)
  */
 export function getReadyTasks(allTasks: AnyTask[]): AnyTask[] {
-  return allTasks.filter(t => {
+  return allTasks.filter((t) => {
     if (t.status !== 'queued' && t.status !== 'pending') return false
 
     if (!t.dependencies || t.dependencies.length === 0) return true
 
-    return t.dependencies
-      .filter(d => d.type === 'blocked_by')
-      .every(d => d.satisfied)
+    return t.dependencies.filter((d) => d.type === 'blocked_by').every((d) => d.satisfied)
   })
 }
 
@@ -513,7 +528,7 @@ export function hasCycles(allTasks: AnyTask[]): boolean {
     visited.add(taskId)
     recStack.add(taskId)
 
-    const task = allTasks.find(t => t.id === taskId)
+    const task = allTasks.find((t) => t.id === taskId)
     if (task?.dependencies) {
       for (const dep of task.dependencies) {
         if (dep.type === 'blocked_by') {
@@ -554,7 +569,7 @@ export function sortTasks(allTasks: AnyTask[]): AnyTask[] {
     if (task.dependencies) {
       for (const dep of task.dependencies) {
         if (dep.type === 'blocked_by') {
-          const depTask = allTasks.find(t => t.id === dep.taskId)
+          const depTask = allTasks.find((t) => t.id === dep.taskId)
           if (depTask) visit(depTask)
         }
       }

package/src/queue.ts

@@ -49,12 +49,14 @@ class InMemoryTaskQueue implements TaskQueue {
   }
 
   async add(task: AnyTask): Promise<void> {
+    // Read the underlying Tool, tolerating the legacy `function` alias.
+    const tool = task.tool ?? task.function
     // Add created event
     const event: TaskEvent = {
       id: `evt_${Date.now()}`,
       type: 'created',
       timestamp: new Date(),
-      message: `Task created: ${task.function.name}`,
+      message: `Task created: ${tool?.name ?? task.id}`,
     }
 
     const taskWithEvent = {
@@ -88,10 +90,16 @@ class InMemoryTaskQueue implements TaskQueue {
     if (options.status && options.status !== task.status) {
       events.push({
         id: `evt_${Date.now()}_status`,
-        type: options.status === 'completed' ? 'completed' :
-              options.status === 'failed' ? 'failed' :
-              options.status === 'in_progress' ? 'started' :
-              options.status === 'blocked' ? 'blocked' : 'progress',
+        type:
+          options.status === 'completed'
+            ? 'completed'
+            : options.status === 'failed'
+            ? 'failed'
+            : options.status === 'in_progress'
+            ? 'started'
+            : options.status === 'blocked'
+            ? 'blocked'
+            : 'progress',
         timestamp: new Date(),
         message: `Status changed from ${task.status} to ${options.status}`,
       })
@@ -102,12 +110,25 @@ class InMemoryTaskQueue implements TaskQueue {
     if (options.progress) {
       progressUpdate = {
         percent: options.progress.percent ?? task.progress?.percent ?? 0,
-        step: options.progress.step ?? task.progress?.step,
-        totalSteps: options.progress.totalSteps ?? task.progress?.totalSteps,
-        currentStep: options.progress.currentStep ?? task.progress?.currentStep,
-        estimatedTimeRemaining: options.progress.estimatedTimeRemaining ?? task.progress?.estimatedTimeRemaining,
         updatedAt: new Date(),
       }
+      const step = options.progress.step ?? task.progress?.step
+      if (step !== undefined) {
+        progressUpdate.step = step
+      }
+      const totalSteps = options.progress.totalSteps ?? task.progress?.totalSteps
+      if (totalSteps !== undefined) {
+        progressUpdate.totalSteps = totalSteps
+      }
+      const currentStep = options.progress.currentStep ?? task.progress?.currentStep
+      if (currentStep !== undefined) {
+        progressUpdate.currentStep = currentStep
+      }
+      const estTime =
+        options.progress.estimatedTimeRemaining ?? task.progress?.estimatedTimeRemaining
+      if (estTime !== undefined) {
+        progressUpdate.estimatedTimeRemaining = estTime
+      }
     }
 
     const updated: AnyTask = {
@@ -145,9 +166,9 @@ class InMemoryTaskQueue implements TaskQueue {
       results = results.filter((t) => priorities.includes(t.priority))
     }
 
-    // Filter by function type
+    // Filter by function type (reads `tool` with fallback to legacy `function`)
     if (options.functionType) {
-      results = results.filter((t) => t.function.type === options.functionType)
+      results = results.filter((t) => (t.tool ?? t.function)?.type === options.functionType)
     }
 
     // Filter by assigned worker
@@ -157,9 +178,7 @@ class InMemoryTaskQueue implements TaskQueue {
 
     // Filter by tags
     if (options.tags && options.tags.length > 0) {
-      results = results.filter(
-        (t) => t.tags && options.tags!.some((tag) => t.tags!.includes(tag))
-      )
+      results = results.filter((t) => t.tags && options.tags!.some((tag) => t.tags!.includes(tag)))
     }
 
     // Filter by project
@@ -172,14 +191,17 @@ class InMemoryTaskQueue implements TaskQueue {
       results = results.filter((t) => t.parentId === options.parentId)
     }
 
-    // Text search
+    // Text search (reads `tool` with fallback to legacy `function`)
     if (options.search) {
       const search = options.search.toLowerCase()
-      results = results.filter(
-        (t) =>
-          t.function.name.toLowerCase().includes(search) ||
-          t.function.description?.toLowerCase().includes(search)
-      )
+      results = results.filter((t) => {
+        const tool = t.tool ?? t.function
+        if (!tool) return false
+        return (
+          tool.name.toLowerCase().includes(search) ||
+          tool.description?.toLowerCase().includes(search)
+        )
+      })
     }
 
     // Sort
@@ -232,7 +254,11 @@ class InMemoryTaskQueue implements TaskQueue {
     // Find first task the worker can handle
     for (const task of queuedTasks) {
       // Check if worker type is allowed
-      if (task.allowedWorkers && !task.allowedWorkers.includes(worker.type) && !task.allowedWorkers.includes('any')) {
+      if (
+        task.allowedWorkers &&
+        !task.allowedWorkers.includes(worker.type) &&
+        !task.allowedWorkers.includes('any')
+      ) {
         continue
       }
 
@@ -289,14 +315,17 @@ class InMemoryTaskQueue implements TaskQueue {
     const task = await this.get(taskId)
     if (!task) return
 
+    const event: Omit<TaskEvent, 'id' | 'timestamp'> = {
+      type: 'completed',
+      message: 'Task completed successfully',
+      data: { output },
+    }
+    if (task.assignment?.worker !== undefined) {
+      event.actor = task.assignment.worker
+    }
     await this.update(taskId, {
       status: 'completed',
-      event: {
-        type: 'completed',
-        actor: task.assignment?.worker,
-        message: 'Task completed successfully',
-        data: { output },
-      },
+      event,
     })
 
     // Update task output separately since it's not in UpdateTaskOptions
@@ -328,7 +357,9 @@ class InMemoryTaskQueue implements TaskQueue {
           })
 
           // Unblock if all dependencies satisfied
-          const allSatisfied = updatedDeps.filter((d) => d.type === 'blocked_by').every((d) => d.satisfied)
+          const allSatisfied = updatedDeps
+            .filter((d) => d.type === 'blocked_by')
+            .every((d) => d.satisfied)
           if (allSatisfied && otherTask.status === 'blocked') {
             await this.update(otherTask.id, {
               status: 'queued',
@@ -347,14 +378,17 @@ class InMemoryTaskQueue implements TaskQueue {
     const task = await this.get(taskId)
     if (!task) return
 
+    const event: Omit<TaskEvent, 'id' | 'timestamp'> = {
+      type: 'failed',
+      message: `Task failed: ${error}`,
+      data: { error },
+    }
+    if (task.assignment?.worker !== undefined) {
+      event.actor = task.assignment.worker
+    }
     await this.update(taskId, {
       status: 'failed',
-      event: {
-        type: 'failed',
-        actor: task.assignment?.worker,
-        message: `Task failed: ${error}`,
-        data: { error },
-      },
+      event,
     })
   }
 
@@ -401,13 +435,18 @@ class InMemoryTaskQueue implements TaskQueue {
       }
     }
 
-    return {
+    const stats: TaskQueueStats = {
       total: tasks.length,
       byStatus,
       byPriority,
-      avgWaitTime: waitTimeCount > 0 ? totalWaitTime / waitTimeCount : undefined,
-      avgCompletionTime: completionTimeCount > 0 ? totalCompletionTime / completionTimeCount : undefined,
     }
+    if (waitTimeCount > 0) {
+      stats.avgWaitTime = totalWaitTime / waitTimeCount
+    }
+    if (completionTimeCount > 0) {
+      stats.avgCompletionTime = totalCompletionTime / completionTimeCount
+    }
+    return stats
   }
 }