@pixelbyte-software/pixcode 1.42.2 → 1.42.3

package/server/modules/orchestration/tasks/task-run-graph.ts

@@ -0,0 +1,219 @@
+import type { WorkflowNodeRun, WorkflowRun } from '@/modules/orchestration/workflows/workflow.types.js';
+import { workflowStore } from '@/modules/orchestration/workflows/workflow-store.js';
+import { orchestrationTaskService } from '@/modules/orchestration/tasks/orchestration-task.service.js';
+import type { OrchestrationTask } from '@/modules/orchestration/tasks/orchestration-task.types.js';
+
+export const PIXCODE_TASK_RUN_GRAPH_PROTOCOL = 'pixcode.task-run-graph.v1';
+
+export type TaskRunGraphCriterionStatus = 'pending' | 'passed' | 'failed';
+
+export interface TaskRunGraphCriterion {
+  id: string;
+  label: string;
+  status: TaskRunGraphCriterionStatus;
+  source: 'taskmaster' | 'workflow';
+}
+
+export interface TaskRunGraphRunSummary {
+  id: string;
+  workflowId: string;
+  status: WorkflowRun['status'];
+  startedAt: number;
+  finishedAt?: number;
+  taskmasterId?: string;
+  orchestrationTaskId?: string;
+  changedFiles: string[];
+}
+
+export interface TaskRunGraph {
+  protocol: typeof PIXCODE_TASK_RUN_GRAPH_PROTOCOL;
+  projectId: string;
+  taskmasterId?: string;
+  orchestrationTaskId?: string;
+  workflowRuns: TaskRunGraphRunSummary[];
+  changedFiles: string[];
+  acceptanceCriteria: TaskRunGraphCriterion[];
+  status: {
+    totalRuns: number;
+    completedRuns: number;
+    failedRuns: number;
+    passedCriteria: number;
+    failedCriteria: number;
+  };
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+
+function readRecord(value: unknown): Record<string, unknown> | undefined {
+  return value && typeof value === 'object' ? value as Record<string, unknown> : undefined;
+}
+
+function uniqueStrings(values: Array<string | undefined>): string[] {
+  return [...new Set(values.filter((value): value is string => Boolean(value?.trim())))]
+    .sort((a, b) => a.localeCompare(b));
+}
+
+function taskStatusPassed(status: unknown): boolean {
+  const normalized = String(status ?? '').toLocaleLowerCase('en');
+  return normalized === 'done' || normalized === 'completed';
+}
+
+function taskStatusFailed(status: unknown): boolean {
+  const normalized = String(status ?? '').toLocaleLowerCase('en');
+  return normalized === 'failed' || normalized === 'blocked' || normalized === 'cancelled' || normalized === 'canceled';
+}
+
+function criterionStatus(status: unknown): TaskRunGraphCriterionStatus {
+  if (taskStatusPassed(status)) return 'passed';
+  if (taskStatusFailed(status)) return 'failed';
+  return 'pending';
+}
+
+function taskmasterAcceptanceCriteria(taskmasterTask: Record<string, unknown> | undefined): TaskRunGraphCriterion[] {
+  if (!taskmasterTask) return [];
+
+  const criteria: TaskRunGraphCriterion[] = [];
+  const testStrategy = readString(taskmasterTask.testStrategy) ?? readString(taskmasterTask.test_strategy);
+  if (testStrategy) {
+    criteria.push({
+      id: 'test-strategy',
+      label: testStrategy,
+      status: criterionStatus(taskmasterTask.status),
+      source: 'taskmaster',
+    });
+  }
+
+  const subtasks = Array.isArray(taskmasterTask.subtasks) ? taskmasterTask.subtasks : [];
+  subtasks.forEach((subtask, index) => {
+    const record = readRecord(subtask);
+    if (!record) return;
+    const title = readString(record.title);
+    if (!title) return;
+    criteria.push({
+      id: `subtask-${readString(record.id) ?? index + 1}`,
+      label: title,
+      status: criterionStatus(record.status),
+      source: 'taskmaster',
+    });
+  });
+
+  return criteria;
+}
+
+function metadataTaskmasterId(run: WorkflowRun): string | undefined {
+  return readString(run.metadata?.taskmasterId)
+    ?? readString(readRecord(run.metadata?.taskGraph)?.taskmasterId)
+    ?? readString(readRecord(run.metadata?.replay)?.taskmasterId);
+}
+
+function metadataOrchestrationTaskId(run: WorkflowRun): string | undefined {
+  return readString(run.metadata?.orchestrationTaskId)
+    ?? readString(readRecord(run.metadata?.taskGraph)?.orchestrationTaskId);
+}
+
+function artifactChangedFiles(node: WorkflowNodeRun): string[] {
+  const files: string[] = [];
+
+  if (node.handoffArtifact?.changedFiles) {
+    files.push(...node.handoffArtifact.changedFiles);
+  }
+
+  for (const artifact of node.artifacts ?? []) {
+    const data = readRecord(artifact.data);
+    const metadata = readRecord(artifact.metadata);
+    const candidates = [
+      readString(metadata?.path),
+      readString(metadata?.file),
+      readString(data?.path),
+      readString(data?.file),
+    ];
+    files.push(...candidates.filter((value): value is string => Boolean(value)));
+
+    for (const key of ['files', 'changedFiles']) {
+      const value = data?.[key] ?? metadata?.[key];
+      if (Array.isArray(value)) {
+        files.push(...value.map((entry) => readString(entry)).filter((entry): entry is string => Boolean(entry)));
+      }
+    }
+  }
+
+  return uniqueStrings(files);
+}
+
+export function changedFilesFromWorkflowRun(run: WorkflowRun): string[] {
+  return uniqueStrings(run.nodeRuns.flatMap((node) => artifactChangedFiles(node)));
+}
+
+function workflowRunMatchesTask(run: WorkflowRun, task: OrchestrationTask | undefined, taskmasterId: string | undefined): boolean {
+  const runTaskmasterId = metadataTaskmasterId(run);
+  const runOrchestrationTaskId = metadataOrchestrationTaskId(run);
+  if (taskmasterId && runTaskmasterId === taskmasterId) return true;
+  if (task?.id && runOrchestrationTaskId === task.id) return true;
+  if (task?.workflowRunIds?.includes(run.id)) return true;
+  return false;
+}
+
+function runSummary(run: WorkflowRun): TaskRunGraphRunSummary {
+  return {
+    id: run.id,
+    workflowId: run.workflowId,
+    status: run.status,
+    startedAt: run.startedAt,
+    finishedAt: run.finishedAt,
+    taskmasterId: metadataTaskmasterId(run),
+    orchestrationTaskId: metadataOrchestrationTaskId(run),
+    changedFiles: changedFilesFromWorkflowRun(run),
+  };
+}
+
+export function buildTaskRunGraph({
+  projectId,
+  taskmasterId,
+  taskmasterTask,
+}: {
+  projectId: string;
+  taskmasterId?: string;
+  taskmasterTask?: Record<string, unknown>;
+}): TaskRunGraph {
+  const orchestrationTask = taskmasterId
+    ? orchestrationTaskService.list(projectId).find((task) => task.taskmasterId === taskmasterId)
+    : undefined;
+  const workflowRuns = workflowStore
+    .listRuns()
+    .filter((run) => workflowRunMatchesTask(run, orchestrationTask, taskmasterId))
+    .map(runSummary);
+  const workflowCriteria: TaskRunGraphCriterion[] = workflowRuns.map((run) => ({
+    id: `run-${run.id}`,
+    label: `Workflow ${run.workflowId} ${run.status}`,
+    status: run.status === 'completed' ? 'passed' : run.status === 'failed' || run.status === 'canceled' ? 'failed' : 'pending',
+    source: 'workflow',
+  }));
+  const acceptanceCriteria = [
+    ...taskmasterAcceptanceCriteria(taskmasterTask),
+    ...(orchestrationTask?.acceptanceCriteria ?? []),
+    ...workflowCriteria,
+  ];
+  const changedFiles = uniqueStrings([
+    ...(orchestrationTask?.changedFiles ?? []),
+    ...workflowRuns.flatMap((run) => run.changedFiles),
+  ]);
+
+  return {
+    protocol: PIXCODE_TASK_RUN_GRAPH_PROTOCOL,
+    projectId,
+    taskmasterId,
+    orchestrationTaskId: orchestrationTask?.id,
+    workflowRuns,
+    changedFiles,
+    acceptanceCriteria,
+    status: {
+      totalRuns: workflowRuns.length,
+      completedRuns: workflowRuns.filter((run) => run.status === 'completed').length,
+      failedRuns: workflowRuns.filter((run) => run.status === 'failed' || run.status === 'canceled').length,
+      passedCriteria: acceptanceCriteria.filter((criterion) => criterion.status === 'passed').length,
+      failedCriteria: acceptanceCriteria.filter((criterion) => criterion.status === 'failed').length,
+    },
+  };
+}

package/server/modules/orchestration/workflows/workflow-runner.ts

@@ -28,6 +28,7 @@ import {
   workspaceTargetMetadata,
 } from '@/modules/orchestration/workflows/workspace-target.js';
 import { workflowStore } from '@/modules/orchestration/workflows/workflow-store.js';
+import { orchestrationTaskService } from '@/modules/orchestration/tasks/orchestration-task.service.js';
 // @ts-ignore — plain-JS service
 import {
   getDefaultProviderModel,
@@ -1215,7 +1216,7 @@ class WorkflowRunner {
     const runtimeWorkflow = expandWorkflowForRun(workflow, metadata);
     validateWorkflow(runtimeWorkflow);
     const workspaceTarget = resolveWorkflowWorkspace(metadata);
-    const runMetadata = {
+    const runMetadata: Record<string, unknown> = {
       ...metadata,
       projectPath: workspaceTarget.projectPath,
       selectedProjectPath: workspaceTarget.selectedProjectPath,
@@ -1232,6 +1233,10 @@ class WorkflowRunner {
       metadata: runMetadata,
     };
     workflowStore.setRun(run);
+    const orchestrationTaskId = readString(runMetadata.orchestrationTaskId);
+    if (orchestrationTaskId) {
+      orchestrationTaskService.linkWorkflowRun(orchestrationTaskId, run);
+    }
     void this.execute(runtimeWorkflow, run);
     return run;
   }
@@ -1591,6 +1596,7 @@ class WorkflowRunner {
     } finally {
       run.finishedAt = run.finishedAt ?? Date.now();
       workflowStore.setRun(run);
+      orchestrationTaskService.updateFromWorkflowRun(run);
       notifyWorkflowRunFinished(run);
       this.cancelingRuns.delete(run.id);
     }

package/server/routes/taskmaster.js

@@ -16,6 +16,9 @@ import express from 'express';
 import crossSpawn from 'cross-spawn';
 
 import { orchestrationTaskService } from '@/modules/orchestration/tasks/orchestration-task.service.js';
+import { buildTaskRunGraph } from '@/modules/orchestration/tasks/task-run-graph.js';
+import { workflowRunner } from '@/modules/orchestration/workflows/workflow-runner.js';
+import { workflowStore } from '@/modules/orchestration/workflows/workflow-store.js';
 
 import { extractProjectDirectory } from '../projects.js';
 import {
@@ -167,6 +170,21 @@ function taskMasterExecutionDescription(task) {
     ].filter(Boolean).join('\n\n');
 }
 
+function taskGraphForTask(projectId, task) {
+    return buildTaskRunGraph({
+        projectId,
+        taskmasterId: String(task.id),
+        taskmasterTask: task,
+    });
+}
+
+function attachTaskGraph(projectId, task) {
+    return {
+        ...task,
+        taskGraph: taskGraphForTask(projectId, task),
+    };
+}
+
 function buildTaskMasterQueueSummary(projectName, projectPath, tasks) {
     const normalized = tasks.map((task) => ({
         ...task,
@@ -389,22 +407,26 @@ router.delete('/install/:jobId', async (req, res) => {
 router.get('/tasks/:projectName', async (req, res) => {
     try {
         const { projectName } = req.params;
+        const projectId = typeof req.query.projectId === 'string' && req.query.projectId.trim()
+            ? req.query.projectId.trim()
+            : projectName;
 
         const { projectPath, transformedTasks, currentTag } = await readTaskMasterTasks(projectName);
+        const tasksWithGraph = transformedTasks.map((task) => attachTaskGraph(projectId, task));
 
         res.json({
             projectName,
             projectPath,
-            tasks: transformedTasks,
+            tasks: tasksWithGraph,
             currentTag,
-            totalTasks: transformedTasks.length,
+            totalTasks: tasksWithGraph.length,
             tasksByStatus: {
-                pending: transformedTasks.filter(t => t.status === 'pending').length,
-                'in-progress': transformedTasks.filter(t => t.status === 'in-progress').length,
-                done: transformedTasks.filter(t => t.status === 'done').length,
-                review: transformedTasks.filter(t => t.status === 'review').length,
-                deferred: transformedTasks.filter(t => t.status === 'deferred').length,
-                cancelled: transformedTasks.filter(t => t.status === 'cancelled').length
+                pending: tasksWithGraph.filter(t => t.status === 'pending').length,
+                'in-progress': tasksWithGraph.filter(t => t.status === 'in-progress').length,
+                done: tasksWithGraph.filter(t => t.status === 'done').length,
+                review: tasksWithGraph.filter(t => t.status === 'review').length,
+                deferred: tasksWithGraph.filter(t => t.status === 'deferred').length,
+                cancelled: tasksWithGraph.filter(t => t.status === 'cancelled').length
             },
             timestamp: new Date().toISOString()
         });
@@ -459,6 +481,9 @@ router.get('/queue/:projectName', async (req, res) => {
 router.get('/task/:projectName/:taskId', async (req, res) => {
     try {
         const { projectName, taskId } = req.params;
+        const projectId = typeof req.query.projectId === 'string' && req.query.projectId.trim()
+            ? req.query.projectId.trim()
+            : projectName;
         const { projectPath, transformedTasks } = await readTaskMasterTasks(projectName);
         const task = transformedTasks.find((candidate) => String(candidate.id) === String(taskId));
         if (!task) {
@@ -472,7 +497,8 @@ router.get('/task/:projectName/:taskId', async (req, res) => {
             success: true,
             projectName,
             projectPath,
-            task,
+            task: attachTaskGraph(projectId, task),
+            taskGraph: taskGraphForTask(projectId, task),
             execution: {
                 supportsProvider: true,
                 supportsModel: true,
@@ -505,6 +531,7 @@ router.post('/execute/:projectName/:taskId', async (req, res) => {
                 : '';
         const model = typeof req.body?.model === 'string' ? req.body.model : undefined;
         const permissionMode = typeof req.body?.permissionMode === 'string' ? req.body.permissionMode : undefined;
+        const workflowId = typeof req.body?.workflowId === 'string' ? req.body.workflowId : undefined;
         const fallbackProvider = typeof req.body?.fallbackProvider === 'string' ? req.body.fallbackProvider : undefined;
         const workerSlot = Number.isInteger(req.body?.workerSlot) ? req.body.workerSlot : undefined;
         const isolation = ['host', 'worktree', 'docker'].includes(req.body?.isolation)
@@ -544,15 +571,49 @@ router.post('/execute/:projectName/:taskId', async (req, res) => {
             },
         });
 
-        const dispatchedTask = await orchestrationTaskService.dispatch(orchestrationTask.id, {
-            adapterId,
-            isolation,
-            projectPath,
-            model,
-            permissionMode,
-            fallbackProvider,
-            workerSlot,
-        });
+        let dispatchedTask;
+        let workflowRun;
+        if (workflowId) {
+            const workflow = workflowStore.getWorkflow(workflowId);
+            if (!workflow) {
+                return res.status(404).json({
+                    success: false,
+                    error: 'Workflow not found',
+                    message: `Workflow "${workflowId}" was not found`
+                });
+            }
+            workflowRun = workflowRunner.start(workflow, taskMasterExecutionDescription(task), {
+                projectId,
+                projectName,
+                projectPath,
+                selectedProjectPath: projectPath,
+                taskmasterId: String(task.id),
+                taskmasterTaskTitle: task.title,
+                orchestrationTaskId: orchestrationTask.id,
+                workflowName: workflow.name,
+                settings: {
+                    isolation,
+                    keepWorkspace: true,
+                    baseRef: 'HEAD',
+                },
+                taskGraph: {
+                    taskmasterId: String(task.id),
+                    orchestrationTaskId: orchestrationTask.id,
+                    source: 'taskmaster',
+                },
+            });
+            dispatchedTask = orchestrationTaskService.linkWorkflowRun(orchestrationTask.id, workflowRun) ?? orchestrationTask;
+        } else {
+            dispatchedTask = await orchestrationTaskService.dispatch(orchestrationTask.id, {
+                adapterId,
+                isolation,
+                projectPath,
+                model,
+                permissionMode,
+                fallbackProvider,
+                workerSlot,
+            });
+        }
 
         res.json({
             success: true,
@@ -565,8 +626,11 @@ router.post('/execute/:projectName/:taskId', async (req, res) => {
                 permissionMode,
                 fallbackProvider,
                 workerSlot,
+                workflowId,
             },
-            task: dispatchedTask
+            task: dispatchedTask,
+            run: workflowRun,
+            taskGraph: taskGraphForTask(projectId, task),
         });
     } catch (error) {
         console.error('TaskMaster execute error:', error);
@@ -591,14 +655,17 @@ router.post('/sync-orchestration/:projectName', async (req, res) => {
             ? req.body.projectId.trim()
             : projectName;
 
-        const syncedTasks = transformedTasks.map((task) =>
-            orchestrationTaskService.upsertFromTaskMaster({
+        const syncedTasks = transformedTasks.map((task) => {
+            const taskGraph = taskGraphForTask(projectId, task);
+            return orchestrationTaskService.upsertFromTaskMaster({
                 projectId,
                 taskmasterId: String(task.id),
                 title: task.title,
                 description: task.description,
-            })
-        );
+                acceptanceCriteria: taskGraph.acceptanceCriteria,
+                changedFiles: taskGraph.changedFiles,
+            });
+        });
 
         res.json({
             success: true,