Workflow Composition | Bootspring Docs

Workflow Composition allows you to chain multiple workflows together, creating complex multi-stage processes that execute in sequence.

Overview#

Instead of running workflows independently:

workflow-1    workflow-2    workflow-3
[========]    [========]    [========]
   done          done          done

Chain them into a composition:

composition: full-feature
┌──────────────────────────────────────────────────────┐
│ workflow-1 ────▶ workflow-2 ────▶ workflow-3        │
│ [========]       [========]       [========]        │
│                                      ▲              │
│                            auto-advance             │
└──────────────────────────────────────────────────────┘

Built-in Templates#

Full Feature#

Complete feature from development to launch.

{
  name: 'full-feature',
  workflows: ['feature-development', 'security-audit', 'launch-preparation']
}

Development Cycle#

Standard development cycle with review.

{
  name: 'development-cycle',
  workflows: ['feature-development', 'performance-optimization']
}

Complete Audit#

Full audit across security, performance, and code quality.

{
  name: 'complete-audit',
  workflows: ['security-audit', 'performance-optimization']
}

Creating Compositions#

From Template#

bootspring composition start full-feature

const composer = require('bootspring/intelligence/workflow-composer');

const result = composer.createFromTemplate('full-feature');
// {
//   success: true,
//   compositionId: 'comp-abc123',
//   workflows: ['feature-development', 'security-audit', 'launch-preparation']
// }

Custom Composition#

bootspring composition create my-process \
  --workflows feature-development,testing-workflow,deploy-workflow

composer.createComposition('my-process', [
  'feature-development',
  'security-audit',
  'launch-preparation'
], {
  description: 'Full feature lifecycle',
  autoAdvance: true
});

Running Compositions#

Start a Composition#

bootspring composition start my-process

const result = composer.startComposition('my-process');
// {
//   success: true,
//   compositionId: 'comp-abc123',
//   currentWorkflow: 'feature-development',
//   currentPhase: { name: 'Design', agents: [...] }
// }

Check Status#

bootspring composition status

const status = composer.getCompositionStatus('comp-abc123');
// {
//   compositionId: 'comp-abc123',
//   name: 'my-process',
//   status: 'active',
//   currentWorkflowIndex: 0,
//   currentWorkflow: 'feature-development',
//   progress: { completed: 0, total: 3, percent: 0 },
//   completedWorkflows: []
// }

Advance Composition#

When a workflow completes, advance to the next:

bootspring composition advance

const result = composer.advanceComposition();
// {
//   success: true,
//   previousWorkflow: 'feature-development',
//   currentWorkflow: 'security-audit',
//   isComplete: false
// }

Complete Composition#

// When last workflow finishes
const result = composer.advanceComposition();
// {
//   success: true,
//   isComplete: true,
//   totalDuration: 432000000,
//   completedWorkflows: [...]
// }

Composition Options#

Auto-Advance#

Automatically advance to the next workflow when the current one completes:

composer.createComposition('auto-process', workflows, {
  autoAdvance: true  // No manual advance needed
});

Failure Handling#

Configure how failures are handled:

composer.createComposition('resilient-process', workflows, {
  onFailure: 'pause',  // 'pause' | 'skip' | 'abort'
  notifyOnFailure: true
});

Conditional Workflows#

Skip workflows based on conditions:

composer.createComposition('conditional-process', [
  'feature-development',
  { workflow: 'security-audit', condition: 'hasSecurityChanges' },
  'launch-preparation'
]);

Managing Compositions#

List Compositions#

bootspring composition list

const compositions = composer.listCompositions();

Resume a Paused Composition#

bootspring composition resume <composition-id>

composer.resumeComposition(compositionId);

Cancel a Composition#

bootspring composition cancel <composition-id>

composer.cancelComposition(compositionId);

Workflow Dependencies#

Define dependencies between workflows in a composition:

composer.createComposition('dependent-process', [
  { workflow: 'api-development', id: 'api' },
  { workflow: 'frontend-development', id: 'frontend', dependsOn: ['api'] },
  { workflow: 'testing-workflow', id: 'testing', dependsOn: ['api', 'frontend'] }
]);

Composition Events#

Track composition progress with events:

// Listen for composition events
composer.on('workflow-started', (event) => {
  console.log(`Started: ${event.workflow}`);
});

composer.on('workflow-completed', (event) => {
  console.log(`Completed: ${event.workflow}`);
});

composer.on('composition-completed', (event) => {
  console.log(`All workflows complete: ${event.compositionId}`);
});

Best Practices#

Plan your sequence - Order workflows logically (dev → test → deploy)
Use auto-advance - For smooth, uninterrupted processes
Handle failures - Configure appropriate failure handling
Monitor progress - Check status regularly for long compositions
Use templates - Start with built-in templates when possible

Example: Full Feature Lifecycle#

// Create a comprehensive feature lifecycle
composer.createComposition('feature-lifecycle', [
  'feature-development',   // Design → Implement → Test → Review
  'security-audit',        // Code Review → Scan → Remediate
  'performance-optimization', // Analyze → Optimize → Benchmark
  'launch-preparation'     // Final checks → Deploy → Monitor
], {
  description: 'Complete feature from idea to production',
  autoAdvance: true,
  onFailure: 'pause'
});

// Start it
composer.startComposition('feature-lifecycle');

// Check progress
const status = composer.getCompositionStatus('feature-lifecycle');
console.log(`Progress: ${status.progress.percent}%`);