@elyracode/workflows 0.7.9

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# Changelog
+
+## [0.7.9] - 2026-05-23
+
+### Added
+- Code-orchestrated workflow engine with `prompt`, `run`, `if`, and `parallel` step types
+- `/workflow` command to list and execute workflows from `.elyra/workflows/`
+- Template interpolation for passing data between steps (`{{steps.name.output}}`)
+- `elyra-workflows` skill for teaching the agent about workflow patterns

package/README.md

@@ -0,0 +1,44 @@
+# @elyracode/workflows
+
+Code-orchestrated workflows for Elyra. Define multi-step pipelines where code handles the control flow and the LLM handles judgment — no token tax from LLM-based orchestration.
+
+## Why
+
+Traditional agent orchestration uses one LLM to plan, spawn sub-agents, collect results, and decide next steps. Every sub-agent result re-enters the orchestrator's context window, paying a "token tax" that degrades quality as the window fills.
+
+Workflows flip this: code orchestrates, the LLM only judges. Each step is focused, deterministic, and reproducible.
+
+## Install
+
+```bash
+elyra install npm:@elyracode/workflows
+```
+
+## Usage
+
+Create workflow files in `.elyra/workflows/`:
+
+```json
+{
+  "name": "deploy",
+  "description": "Build, test, review, deploy",
+  "steps": [
+    { "name": "test", "run": "npm test" },
+    { "name": "review", "prompt": "Review test results:\n{{steps.test.output}}" },
+    { "name": "deploy", "run": "npm run deploy", "if": "{{steps.test.code}} == 0" }
+  ]
+}
+```
+
+Run with `/workflow deploy` or ask the agent to run it.
+
+## Step Types
+
+- **`prompt`** — Send a focused prompt to the LLM
+- **`run`** — Execute a shell command
+- **`if`** — Conditional execution based on previous step results
+- **`parallel`** — Run multiple steps concurrently
+
+## Template Variables
+
+Reference previous step outputs with `{{steps.<name>.output}}`, `{{steps.<name>.code}}`, or `{{steps.<name>.stderr}}`.

package/extensions/index.ts

@@ -0,0 +1,401 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import type { ExtensionAPI } from "@elyracode/coding-agent";
+import { Type } from "typebox";
+
+// ── Types ───────────────────────────────────────────────────────────────────
+
+interface WorkflowStep {
+	name: string;
+	prompt?: string;
+	run?: string;
+	if?: string;
+	parallel?: WorkflowStep[];
+}
+
+interface WorkflowDefinition {
+	name: string;
+	description?: string;
+	steps: WorkflowStep[];
+}
+
+interface StepResult {
+	output: string;
+	stderr?: string;
+	code?: number;
+	skipped?: boolean;
+	type: "prompt" | "run" | "parallel" | "skipped";
+}
+
+interface WorkflowContext {
+	steps: Record<string, StepResult>;
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────────────
+
+function interpolate(template: string, ctx: WorkflowContext): string {
+	return template.replace(/\{\{steps\.(\w+)\.(\w+)\}\}/g, (_match, stepName: string, field: string) => {
+		const step = ctx.steps[stepName];
+		if (!step) return `(step "${stepName}" not found)`;
+		if (field === "output") return step.output ?? "";
+		if (field === "stderr") return step.stderr ?? "";
+		if (field === "code") return String(step.code ?? "");
+		return `(unknown field "${field}")`;
+	});
+}
+
+function evaluateCondition(condition: string, ctx: WorkflowContext): boolean {
+	const interpolated = interpolate(condition, ctx).trim();
+
+	// Simple equality: "value == expected"
+	const eqMatch = interpolated.match(/^(.+?)\s*==\s*(.+)$/);
+	if (eqMatch) {
+		return eqMatch[1].trim() === eqMatch[2].trim();
+	}
+
+	// Simple inequality: "value != expected"
+	const neqMatch = interpolated.match(/^(.+?)\s*!=\s*(.+)$/);
+	if (neqMatch) {
+		return neqMatch[1].trim() !== neqMatch[2].trim();
+	}
+
+	// Contains: 'text contains "word"'
+	const containsMatch = interpolated.match(/^(.+?)\s+contains\s+"(.+)"$/);
+	if (containsMatch) {
+		return containsMatch[1].includes(containsMatch[2]);
+	}
+
+	// Truthy: non-empty, non-zero
+	return interpolated !== "" && interpolated !== "0" && interpolated !== "false";
+}
+
+function loadWorkflows(workflowDir: string): WorkflowDefinition[] {
+	if (!existsSync(workflowDir)) return [];
+
+	const files = readdirSync(workflowDir).filter((f) => f.endsWith(".json"));
+	const workflows: WorkflowDefinition[] = [];
+
+	for (const file of files) {
+		try {
+			const content = readFileSync(join(workflowDir, file), "utf-8");
+			const parsed = JSON.parse(content) as WorkflowDefinition;
+			if (parsed.name && Array.isArray(parsed.steps)) {
+				workflows.push(parsed);
+			}
+		} catch {
+			// Skip invalid files
+		}
+	}
+
+	return workflows;
+}
+
+function formatStepResult(name: string, result: StepResult): string {
+	if (result.skipped) {
+		return `[${name}] skipped (condition not met)`;
+	}
+	if (result.type === "run") {
+		const status = result.code === 0 ? "ok" : `exit ${result.code}`;
+		const output = result.output ? `\n${result.output}` : "";
+		const stderr = result.stderr ? `\nstderr: ${result.stderr}` : "";
+		return `[${name}] run (${status})${output}${stderr}`;
+	}
+	if (result.type === "prompt") {
+		return `[${name}] prompt completed`;
+	}
+	if (result.type === "parallel") {
+		return `[${name}] parallel (${result.output})`;
+	}
+	return `[${name}] done`;
+}
+
+function truncate(text: string, maxLen: number): string {
+	if (text.length <= maxLen) return text;
+	return `${text.slice(0, maxLen)}... (truncated)`;
+}
+
+// ── Extension ───────────────────────────────────────────────────────────────
+
+export default function (elyra: ExtensionAPI): void {
+	let cwd = "";
+	let workflows: WorkflowDefinition[] = [];
+
+	elyra.on("session_start", async (_event, ctx) => {
+		cwd = ctx.cwd;
+		const workflowDir = join(cwd, ".elyra", "workflows");
+		workflows = loadWorkflows(workflowDir);
+	});
+
+	// ── /workflow command ─────────────────────────────────────────────────
+
+	elyra.registerCommand("workflow", {
+		description: "Run a code-orchestrated workflow from .elyra/workflows/",
+		async handler(args, ctx) {
+			const workflowDir = join(cwd, ".elyra", "workflows");
+			workflows = loadWorkflows(workflowDir);
+
+			if (!args.trim()) {
+				// List available workflows
+				if (workflows.length === 0) {
+					ctx.ui.notify(
+						"No workflows found. Create JSON files in .elyra/workflows/",
+						"info",
+					);
+					return;
+				}
+				const list = workflows
+					.map((w) => `  ${w.name}${w.description ? ` — ${w.description}` : ""}`)
+					.join("\n");
+				ctx.ui.notify(`Available workflows:\n${list}\n\nRun with: /workflow <name>`, "info");
+				return;
+			}
+
+			const name = args.trim();
+			const workflow = workflows.find((w) => w.name === name);
+			if (!workflow) {
+				ctx.ui.notify(`Workflow "${name}" not found. Run /workflow to list available workflows.`, "error");
+				return;
+			}
+
+			// Execute the workflow
+			ctx.ui.notify(`Starting workflow: ${workflow.name}`, "info");
+			const context: WorkflowContext = { steps: {} };
+			const log: string[] = [];
+
+			for (const step of workflow.steps) {
+				// Check condition
+				if (step.if) {
+					const shouldRun = evaluateCondition(step.if, context);
+					if (!shouldRun) {
+						context.steps[step.name] = { output: "", skipped: true, type: "skipped" };
+						log.push(formatStepResult(step.name, context.steps[step.name]));
+						continue;
+					}
+				}
+
+				// Parallel steps
+				if (step.parallel && step.parallel.length > 0) {
+					ctx.ui.notify(`[${step.name}] running ${step.parallel.length} parallel steps...`, "info");
+					const results = await Promise.all(
+						step.parallel.map(async (subStep) => {
+							if (subStep.run) {
+								const cmd = interpolate(subStep.run, context);
+								const result = await elyra.exec("sh", ["-c", cmd], { timeout: 120_000, cwd });
+								return {
+									name: subStep.name,
+									result: {
+										output: result.stdout,
+										stderr: result.stderr,
+										code: result.code,
+										type: "run" as const,
+									},
+								};
+							}
+							return {
+								name: subStep.name,
+								result: { output: "", type: "run" as const },
+							};
+						}),
+					);
+					for (const r of results) {
+						context.steps[r.name] = r.result;
+					}
+					const summary = results.map((r) => `${r.name}: ${r.result.code === 0 ? "ok" : `exit ${r.result.code}`}`).join(", ");
+					context.steps[step.name] = { output: summary, type: "parallel" };
+					log.push(formatStepResult(step.name, context.steps[step.name]));
+					continue;
+				}
+
+				// Run step
+				if (step.run) {
+					const cmd = interpolate(step.run, context);
+					ctx.ui.notify(`[${step.name}] running: ${truncate(cmd, 80)}`, "info");
+					const result = await elyra.exec("sh", ["-c", cmd], { timeout: 120_000, cwd });
+					context.steps[step.name] = {
+						output: result.stdout,
+						stderr: result.stderr,
+						code: result.code,
+						type: "run",
+					};
+					log.push(formatStepResult(step.name, context.steps[step.name]));
+					continue;
+				}
+
+				// Prompt step
+				if (step.prompt) {
+					const prompt = interpolate(step.prompt, context);
+					ctx.ui.notify(`[${step.name}] sending prompt to agent...`, "info");
+					await ctx.sendUserMessage(prompt);
+					// The agent response will be in the session; capture it conceptually
+					context.steps[step.name] = {
+						output: "(agent responded in session)",
+						type: "prompt",
+					};
+					log.push(formatStepResult(step.name, context.steps[step.name]));
+					continue;
+				}
+			}
+
+			// Summary
+			const summary = [
+				`Workflow "${workflow.name}" completed (${workflow.steps.length} steps):`,
+				"",
+				...log,
+			].join("\n");
+			ctx.ui.notify(summary, "info");
+		},
+	});
+
+	// ── workflow_run tool ─────────────────────────────────────────────────
+
+	const runSchema = Type.Object({
+		name: Type.String({ description: "Name of the workflow to execute" }),
+	});
+
+	elyra.registerTool({
+		name: "workflow_run",
+		label: "Run Workflow",
+		description:
+			"Execute a code-orchestrated workflow from .elyra/workflows/. Workflows define multi-step pipelines where code handles control flow (sequencing, conditions, parallelism) and the LLM handles judgment (analysis, review, generation). Use this when the user asks to run a defined workflow.",
+		parameters: runSchema,
+		promptSnippet: "Run a workflow pipeline from .elyra/workflows/",
+		promptGuidelines: [
+			"List available workflows by reading .elyra/workflows/ directory",
+			"Suggest creating a workflow when the user describes a repeatable multi-step process",
+		],
+		async execute(_toolCallId, params) {
+			const workflowDir = join(cwd, ".elyra", "workflows");
+			workflows = loadWorkflows(workflowDir);
+
+			const workflow = workflows.find((w) => w.name === params.name);
+			if (!workflow) {
+				const available = workflows.map((w) => w.name).join(", ") || "none";
+				return {
+					content: [{ type: "text", text: `Workflow "${params.name}" not found. Available: ${available}` }],
+					isError: true,
+				};
+			}
+
+			const context: WorkflowContext = { steps: {} };
+			const log: string[] = [`Executing workflow: ${workflow.name}`];
+
+			for (const step of workflow.steps) {
+				// Check condition
+				if (step.if) {
+					if (!evaluateCondition(step.if, context)) {
+						context.steps[step.name] = { output: "", skipped: true, type: "skipped" };
+						log.push(`[${step.name}] skipped`);
+						continue;
+					}
+				}
+
+				// Run step
+				if (step.run) {
+					const cmd = interpolate(step.run, context);
+					const result = await elyra.exec("sh", ["-c", cmd], { timeout: 120_000, cwd });
+					context.steps[step.name] = {
+						output: result.stdout,
+						stderr: result.stderr,
+						code: result.code,
+						type: "run",
+					};
+					const status = result.code === 0 ? "ok" : `exit ${result.code}`;
+					log.push(`[${step.name}] run (${status}): ${truncate(result.stdout, 200)}`);
+					continue;
+				}
+
+				// Prompt step — return the prompt for the agent to process
+				if (step.prompt) {
+					const prompt = interpolate(step.prompt, context);
+					context.steps[step.name] = { output: prompt, type: "prompt" };
+					log.push(`[${step.name}] prompt ready`);
+					// Return early — the agent should process this prompt
+					return {
+						content: [
+							{
+								type: "text",
+								text: [
+									...log,
+									"",
+									`Step "${step.name}" requires LLM judgment. Process this prompt:`,
+									"",
+									prompt,
+									"",
+									`Remaining steps: ${workflow.steps
+										.slice(workflow.steps.indexOf(step) + 1)
+										.map((s) => s.name)
+										.join(", ") || "none"}`,
+								].join("\n"),
+							},
+						],
+					};
+				}
+
+				// Parallel
+				if (step.parallel) {
+					const results = await Promise.all(
+						step.parallel.map(async (sub) => {
+							if (sub.run) {
+								const cmd = interpolate(sub.run, context);
+								const r = await elyra.exec("sh", ["-c", cmd], { timeout: 120_000, cwd });
+								return { name: sub.name, output: r.stdout, code: r.code };
+							}
+							return { name: sub.name, output: "", code: 0 };
+						}),
+					);
+					for (const r of results) {
+						context.steps[r.name] = { output: r.output, code: r.code, type: "run" };
+					}
+					const summary = results.map((r) => `${r.name}: ${r.code === 0 ? "ok" : `exit ${r.code}`}`).join(", ");
+					context.steps[step.name] = { output: summary, type: "parallel" };
+					log.push(`[${step.name}] parallel: ${summary}`);
+				}
+			}
+
+			return {
+				content: [{ type: "text", text: log.join("\n") }],
+			};
+		},
+	});
+
+	// ── workflow_list tool ────────────────────────────────────────────────
+
+	const listSchema = Type.Object({});
+
+	elyra.registerTool({
+		name: "workflow_list",
+		label: "List Workflows",
+		description: "List available workflows defined in .elyra/workflows/. Shows each workflow name, description, and step count.",
+		parameters: listSchema,
+		promptSnippet: "List available workflow pipelines",
+		async execute() {
+			const workflowDir = join(cwd, ".elyra", "workflows");
+			workflows = loadWorkflows(workflowDir);
+
+			if (workflows.length === 0) {
+				return {
+					content: [
+						{
+							type: "text",
+							text: "No workflows found. Create JSON files in .elyra/workflows/ to define pipelines.\n\nExample workflow (.elyra/workflows/check.json):\n```json\n{\n  \"name\": \"check\",\n  \"description\": \"Lint, test, and type-check\",\n  \"steps\": [\n    { \"name\": \"lint\", \"run\": \"npm run lint\" },\n    { \"name\": \"test\", \"run\": \"npm test\" },\n    { \"name\": \"types\", \"run\": \"npm run check\" }\n  ]\n}\n```",
+						},
+					],
+				};
+			}
+
+			const lines = workflows.map((w) => {
+				const stepTypes = w.steps.map((s) => {
+					if (s.prompt) return "prompt";
+					if (s.run) return "run";
+					if (s.parallel) return "parallel";
+					return "?";
+				});
+				return `${w.name} — ${w.description ?? "(no description)"} (${w.steps.length} steps: ${stepTypes.join(", ")})`;
+			});
+
+			return {
+				content: [{ type: "text", text: `Available workflows:\n\n${lines.join("\n")}` }],
+			};
+		},
+	});
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@elyracode/workflows",
+  "version": "0.7.9",
+  "description": "Code-orchestrated workflows for Elyra -- define multi-step pipelines where code handles control flow and LLMs handle judgment",
+  "type": "module",
+  "keywords": [
+    "elyra-package",
+    "workflows",
+    "orchestration",
+    "pipelines",
+    "automation"
+  ],
+  "license": "MIT",
+  "author": "Knut W. Horne",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kwhorne/elyra.git",
+    "directory": "packages/workflows"
+  },
+  "elyra": {
+    "extensions": [
+      "./extensions/index.ts"
+    ],
+    "skills": [
+      "./skills"
+    ]
+  },
+  "peerDependencies": {
+    "@elyracode/coding-agent": "*",
+    "typebox": "*"
+  },
+  "scripts": {
+    "clean": "echo 'nothing to clean'",
+    "build": "echo 'nothing to build'",
+    "check": "echo 'nothing to check'"
+  }
+}

package/skills/elyra-workflows/SKILL.md

@@ -0,0 +1,65 @@
+---
+name: elyra-workflows
+description: Code-orchestrated workflows. Use when the user wants to define multi-step pipelines, automate sequences of tasks, or build reproducible processes that combine code execution with LLM judgment.
+---
+
+# Workflows
+
+## When to Use
+
+Use workflows when:
+- The user wants to automate a multi-step process (build, test, deploy)
+- A task requires both code execution and LLM judgment in sequence
+- The user wants reproducible, deterministic pipelines
+- Multiple steps need to pass data between each other
+
+## Workflow Files
+
+Workflows are JSON files in `.elyra/workflows/`. Each file defines a named pipeline with ordered steps.
+
+## Step Types
+
+| Type | Field | Description |
+|------|-------|-------------|
+| Prompt | `prompt` | Send a prompt to the LLM for judgment, analysis, or generation |
+| Run | `run` | Execute a shell command |
+| Conditional | `if` | Skip this step unless a condition is met |
+| Parallel | `parallel` | Run multiple sub-steps concurrently |
+
+## Template Syntax
+
+Use `{{steps.<name>.output}}` to reference output from a previous step. Available fields:
+- `{{steps.<name>.output}}` — stdout or LLM response
+- `{{steps.<name>.code}}` — exit code (run steps only)
+- `{{steps.<name>.stderr}}` — stderr (run steps only)
+
+## Example Workflow
+
+```json
+{
+  "name": "review-and-fix",
+  "description": "Find issues, fix them, verify the fix",
+  "steps": [
+    {
+      "name": "find-issues",
+      "prompt": "Run the linter and type checker, then list all errors"
+    },
+    {
+      "name": "fix",
+      "prompt": "Fix the issues found:\n{{steps.find-issues.output}}"
+    },
+    {
+      "name": "verify",
+      "run": "npm run check"
+    },
+    {
+      "name": "report",
+      "prompt": "Summarize what was fixed and whether verify passed:\n{{steps.verify.output}}"
+    }
+  ]
+}
+```
+
+## Key Principle
+
+Code handles orchestration. LLMs handle judgment. Each prompt step should be focused on a single task. Don't ask the LLM to plan — the workflow IS the plan.