@elyracode/swarm 0.5.9

package/CHANGELOG.md

@@ -0,0 +1,12 @@
+# Changelog
+
+## [0.5.9] - 2026-05-15
+
+## [0.5.8] - 2026-05-15
+
+### Added
+- Initial release
+- Three automated pipelines: build (plan -> code -> test -> review -> fix), review (analyze -> correctness -> security -> tests -> synthesize), refactor (analyze -> plan -> implement -> verify)
+- `/swarm` command for running pipelines from the editor
+- `swarm` tool for LLM-driven pipeline selection
+- Skill file for automatic delegation when user describes multi-step tasks

package/README.md

@@ -0,0 +1,78 @@
+# @elyracode/swarm
+
+Multi-agent swarm orchestration for Elyra. Automated pipelines where planner, coder, tester, and reviewer agents collaborate on a task with visual progress tracking.
+
+## Install
+
+```
+elyra install npm:@elyracode/swarm
+```
+
+## Pipelines
+
+### Build (`/swarm build <task>`)
+
+Full feature development pipeline:
+
+```
+plan -> code -> test -> review -> fix
+```
+
+1. **Plan**: Analyzes codebase, creates implementation plan with file paths
+2. **Code**: Implements the plan, edits files
+3. **Test**: Writes and runs tests for the implementation
+4. **Review**: Reviews all changes for correctness, security, edge cases
+5. **Fix**: Addresses review findings
+
+### Review (`/swarm review <target>`)
+
+Deep multi-pass code review:
+
+```
+analyze -> correctness -> security -> tests -> synthesize
+```
+
+1. **Analyze**: Maps the code structure and data flow
+2. **Correctness**: Reviews logic, error handling, edge cases
+3. **Security**: Checks for vulnerabilities, input validation, auth issues
+4. **Tests**: Evaluates test coverage and quality
+5. **Synthesize**: Prioritizes all findings into actionable list
+
+### Refactor (`/swarm refactor <target>`)
+
+Structured refactoring:
+
+```
+analyze -> plan -> implement -> verify
+```
+
+1. **Analyze**: Understands current structure, identifies issues
+2. **Plan**: Creates refactoring plan preserving behavior
+3. **Implement**: Executes the refactoring
+4. **Verify**: Confirms behavior is preserved, no regressions
+
+## Usage
+
+### Commands
+
+```
+/swarm build add a notification system with email and in-app channels
+/swarm review the authentication module
+/swarm refactor the database query layer
+/swarm          # lists available pipelines
+```
+
+### Natural Language
+
+Just describe what you want and mention "swarm":
+
+```
+Use swarm to build a REST API for user profiles
+Run a swarm review on the checkout flow
+```
+
+## How It Works
+
+Each pipeline stage runs as a focused agent turn with specific instructions. Results from each stage are passed to the next as context. The agent sees a progress indicator showing which stage is active.
+
+Stages marked as read-only (analyze, review, synthesize) cannot edit files. Only implementation stages (code, fix, implement) can write.

package/extensions/index.ts

@@ -0,0 +1,374 @@
+import type { ExtensionAPI } from "@elyracode/coding-agent";
+import { Type } from "typebox";
+
+// ── Pipeline Definitions ────────────────────────────────────────────────────
+
+interface Stage {
+	name: string;
+	label: string;
+	readOnly: boolean;
+	instructions: string;
+}
+
+interface Pipeline {
+	name: string;
+	description: string;
+	stages: Stage[];
+}
+
+const PIPELINES: Record<string, Pipeline> = {
+	build: {
+		name: "Build",
+		description: "Full feature development: plan, code, test, review, fix",
+		stages: [
+			{
+				name: "plan",
+				label: "Planning",
+				readOnly: true,
+				instructions:
+					"You are the PLANNER. Analyze the codebase to understand the existing architecture, " +
+					"then create a concrete implementation plan.\n\n" +
+					"Deliverables:\n" +
+					"- Step-by-step plan with file paths\n" +
+					"- Files to create, modify, or delete\n" +
+					"- Dependencies and order of operations\n" +
+					"- Database/migration changes if needed\n" +
+					"- Test strategy\n\n" +
+					"Rules: Read files to understand the codebase. Do NOT edit files. Be specific with paths and function names.",
+			},
+			{
+				name: "code",
+				label: "Coding",
+				readOnly: false,
+				instructions:
+					"You are the CODER. Implement the plan from the previous stage.\n\n" +
+					"Rules:\n" +
+					"- Follow the plan precisely\n" +
+					"- Edit files, create new files as specified\n" +
+					"- Keep changes minimal and focused\n" +
+					"- If something is unclear, make a reasonable choice and note it\n" +
+					"- Do not write tests yet (next stage handles that)",
+			},
+			{
+				name: "test",
+				label: "Testing",
+				readOnly: false,
+				instructions:
+					"You are the TESTER. Write tests for the implementation from the previous stages.\n\n" +
+					"Rules:\n" +
+					"- Read the implemented code to understand what was built\n" +
+					"- Write tests covering happy path, edge cases, and error cases\n" +
+					"- Follow the project's existing test patterns and framework\n" +
+					"- Run the tests if possible to verify they pass\n" +
+					"- Do not modify implementation code unless a test reveals a clear bug",
+			},
+			{
+				name: "review",
+				label: "Reviewing",
+				readOnly: true,
+				instructions:
+					"You are the REVIEWER. Review all changes made by the coder and tester.\n\n" +
+					"Check for:\n" +
+					"- Correctness: does it do what was planned?\n" +
+					"- Security: SQL injection, XSS, auth bypasses, data leaks\n" +
+					"- Edge cases: null handling, empty inputs, concurrent access\n" +
+					"- Test quality: coverage, meaningful assertions\n" +
+					"- Simplicity: unnecessary complexity?\n\n" +
+					"Rules: Do NOT edit files. Categorize issues as critical/warning/suggestion. Be specific with file paths and line numbers.",
+			},
+			{
+				name: "fix",
+				label: "Fixing",
+				readOnly: false,
+				instructions:
+					"You are the FIXER. Address the issues found by the reviewer.\n\n" +
+					"Rules:\n" +
+					"- Fix critical issues first\n" +
+					"- Apply warning fixes if they are clearly beneficial\n" +
+					"- Skip pure style suggestions unless trivial\n" +
+					"- Run tests after fixes to ensure nothing broke\n" +
+					"- Summarize what was fixed and what was left as-is",
+			},
+		],
+	},
+	review: {
+		name: "Review",
+		description: "Deep multi-pass code review: analyze, correctness, security, tests, synthesize",
+		stages: [
+			{
+				name: "analyze",
+				label: "Analyzing",
+				readOnly: true,
+				instructions:
+					"You are the ANALYZER. Map the code structure for the target area.\n\n" +
+					"Deliverables:\n" +
+					"- Key files and their responsibilities\n" +
+					"- Data flow and control flow\n" +
+					"- Entry points and external dependencies\n" +
+					"- Architecture patterns used\n\n" +
+					"Rules: Read only. Be concise. Focus on what matters for a review.",
+			},
+			{
+				name: "correctness",
+				label: "Correctness Review",
+				readOnly: true,
+				instructions:
+					"You are the CORRECTNESS REVIEWER. Focus exclusively on logical correctness.\n\n" +
+					"Check:\n" +
+					"- Logic errors, off-by-one, wrong conditions\n" +
+					"- Data handling: null, undefined, type coercion\n" +
+					"- Error handling: uncaught exceptions, missing fallbacks\n" +
+					"- Edge cases: empty arrays, zero values, concurrent access\n\n" +
+					"Rules: Do NOT check style, tests, or security (other reviewers handle those). Read only.",
+			},
+			{
+				name: "security",
+				label: "Security Review",
+				readOnly: true,
+				instructions:
+					"You are the SECURITY REVIEWER. Focus exclusively on security.\n\n" +
+					"Check:\n" +
+					"- SQL injection, XSS, CSRF\n" +
+					"- Authentication and authorization bypasses\n" +
+					"- Data leaks, insecure defaults\n" +
+					"- Input validation and sanitization\n" +
+					"- Secrets in code, insecure storage\n\n" +
+					"Rules: Do NOT check style or correctness. Read only. Rate findings by severity.",
+			},
+			{
+				name: "tests",
+				label: "Test Review",
+				readOnly: true,
+				instructions:
+					"You are the TEST REVIEWER. Focus exclusively on test quality.\n\n" +
+					"Check:\n" +
+					"- Coverage: what is tested and what is missing\n" +
+					"- Assertion quality: meaningful checks vs trivial\n" +
+					"- Edge case coverage: boundaries, errors, empty inputs\n" +
+					"- Test isolation: shared state, flaky patterns\n" +
+					"- Missing test categories: unit, integration, e2e\n\n" +
+					"Rules: Do NOT check implementation code quality. Read only.",
+			},
+			{
+				name: "synthesize",
+				label: "Synthesizing",
+				readOnly: true,
+				instructions:
+					"You are the SYNTHESIZER. Combine all review findings into a single actionable report.\n\n" +
+					"Deliverables:\n" +
+					"- Prioritized list of findings by severity (critical > warning > suggestion)\n" +
+					"- For each finding: what, where, why, and how to fix\n" +
+					"- Overall assessment: ship / fix first / redesign\n" +
+					"- Recommended fix order\n\n" +
+					"Rules: Read only. Be direct. No fluff.",
+			},
+		],
+	},
+	refactor: {
+		name: "Refactor",
+		description: "Structured refactoring: analyze, plan, implement, verify",
+		stages: [
+			{
+				name: "analyze",
+				label: "Analyzing",
+				readOnly: true,
+				instructions:
+					"You are the ANALYZER. Understand the current code structure before refactoring.\n\n" +
+					"Deliverables:\n" +
+					"- Current architecture and patterns\n" +
+					"- Pain points and code smells\n" +
+					"- Dependencies and coupling\n" +
+					"- Existing test coverage\n\n" +
+					"Rules: Read only. Identify what needs to change and why.",
+			},
+			{
+				name: "plan",
+				label: "Planning",
+				readOnly: true,
+				instructions:
+					"You are the PLANNER. Create a refactoring plan that preserves behavior.\n\n" +
+					"Deliverables:\n" +
+					"- Step-by-step refactoring plan\n" +
+					"- Which files change and how\n" +
+					"- Migration strategy if APIs change\n" +
+					"- Risk assessment\n\n" +
+					"Rules: Read only. The plan must ensure no behavior changes (unless explicitly requested).",
+			},
+			{
+				name: "implement",
+				label: "Implementing",
+				readOnly: false,
+				instructions:
+					"You are the IMPLEMENTER. Execute the refactoring plan.\n\n" +
+					"Rules:\n" +
+					"- Follow the plan step by step\n" +
+					"- Preserve all existing behavior\n" +
+					"- Update tests to reflect structural changes\n" +
+					"- Run tests after changes if possible\n" +
+					"- Note any deviations from the plan",
+			},
+			{
+				name: "verify",
+				label: "Verifying",
+				readOnly: true,
+				instructions:
+					"You are the VERIFIER. Confirm the refactoring preserved behavior.\n\n" +
+					"Check:\n" +
+					"- All original functionality still works\n" +
+					"- Tests pass (run them if possible)\n" +
+					"- No regressions introduced\n" +
+					"- Code is actually simpler/better after refactoring\n" +
+					"- No leftover dead code from the old implementation\n\n" +
+					"Rules: Read only. Report any issues found.",
+			},
+		],
+	},
+};
+
+// ── Visual Progress ─────────────────────────────────────────────────────────
+
+function renderPipeline(pipeline: Pipeline, activeIndex: number, completedIndices: Set<number>): string {
+	const lines: string[] = [];
+	const stages = pipeline.stages;
+
+	// Header
+	lines.push(`## Swarm: ${pipeline.name}`);
+	lines.push("");
+
+	// Pipeline visualization
+	const stageLabels = stages.map((stage, i) => {
+		if (completedIndices.has(i)) return `[${stage.label}]`;
+		if (i === activeIndex) return `> ${stage.label} <`;
+		return `  ${stage.label}  `;
+	});
+
+	// Flow line
+	lines.push("```");
+	lines.push(stageLabels.join(" -> "));
+	lines.push("```");
+	lines.push("");
+
+	return lines.join("\n");
+}
+
+function renderStageHeader(pipeline: Pipeline, stageIndex: number, task: string): string {
+	const stage = pipeline.stages[stageIndex]!;
+	const progress = `[${stageIndex + 1}/${pipeline.stages.length}]`;
+	const readOnly = stage.readOnly ? " (read-only)" : "";
+
+	return (
+		`---\n\n` +
+		`### ${progress} ${stage.label}${readOnly}\n\n`
+	);
+}
+
+// ── Extension ───────────────────────────────────────────────────────────────
+
+export default function (elyra: ExtensionAPI): void {
+	// -- Tool: swarm --
+	elyra.registerTool({
+		name: "swarm",
+		label: "Run Swarm Pipeline",
+		description:
+			"Run an automated multi-agent swarm pipeline. Available pipelines: " +
+			"build (plan -> code -> test -> review -> fix), " +
+			"review (analyze -> correctness -> security -> tests -> synthesize), " +
+			"refactor (analyze -> plan -> implement -> verify). " +
+			"Each stage runs as a focused agent with specific instructions. " +
+			"Results pass automatically between stages.",
+		parameters: Type.Object({
+			pipeline: Type.String({
+				description: "Pipeline name: build, review, refactor",
+			}),
+			task: Type.String({
+				description: "The task or target to work on",
+			}),
+		}),
+		execute: async (_toolCallId, params) => {
+			const pipeline = PIPELINES[params.pipeline];
+			if (!pipeline) {
+				const available = Object.entries(PIPELINES)
+					.map(([id, p]) => `  ${id}: ${p.description}`)
+					.join("\n");
+				return {
+					content: [{ type: "text", text: `Unknown pipeline: ${params.pipeline}\n\nAvailable:\n${available}` }],
+					details: {},
+				};
+			}
+
+			const completedIndices = new Set<number>();
+			const parts: string[] = [];
+
+			// Render initial pipeline view
+			parts.push(renderPipeline(pipeline, 0, completedIndices));
+
+			// Generate instructions for all stages
+			for (let i = 0; i < pipeline.stages.length; i++) {
+				const stage = pipeline.stages[i]!;
+				parts.push(renderStageHeader(pipeline, i, params.task));
+
+				parts.push(`**Task**: ${params.task}\n\n`);
+				parts.push(`**Instructions**:\n${stage.instructions}\n\n`);
+
+				if (stage.readOnly) {
+					parts.push(`**Constraint**: This is a read-only stage. Do NOT edit any files.\n\n`);
+				}
+
+				if (i < pipeline.stages.length - 1) {
+					parts.push(`When done, write your output under a "#### ${stage.label} Output" heading, then proceed to the next stage.\n\n`);
+				} else {
+					parts.push(`This is the final stage. Write your output under a "#### ${stage.label} Output" heading, then provide a "## Swarm Summary" with the overall result.\n\n`);
+				}
+
+				completedIndices.add(i);
+			}
+
+			// Final pipeline view (all complete)
+			parts.push("---\n\n");
+			parts.push(renderPipeline(pipeline, -1, completedIndices));
+
+			return {
+				content: [{ type: "text", text: parts.join("") }],
+				details: {
+					pipeline: pipeline.name,
+					stages: pipeline.stages.length,
+					task: params.task,
+				},
+			};
+		},
+	});
+
+	// -- Command: /swarm --
+	elyra.registerCommand("swarm", {
+		description: "Run a multi-agent swarm pipeline: /swarm <pipeline> <task>",
+		handler: async (args, ctx) => {
+			const parts = args.trim().split(/\s+/);
+			const pipelineName = parts[0];
+			const task = parts.slice(1).join(" ");
+
+			if (!pipelineName) {
+				const pipelineList = Object.entries(PIPELINES)
+					.map(([id, p]) => {
+						const stages = p.stages.map((s) => s.name).join(" -> ");
+						return `  **${id}**: ${p.description}\n    ${stages}`;
+					})
+					.join("\n\n");
+				ctx.ui.notify(`Available swarm pipelines:\n\n${pipelineList}\n\nUsage: /swarm <pipeline> <task>`);
+				return;
+			}
+
+			if (!PIPELINES[pipelineName]) {
+				const available = Object.keys(PIPELINES).join(", ");
+				ctx.ui.notify(`Unknown pipeline: ${pipelineName}. Available: ${available}`, "error");
+				return;
+			}
+
+			if (!task) {
+				ctx.ui.notify(`Usage: /swarm ${pipelineName} <task description>`, "error");
+				return;
+			}
+
+			elyra.sendUserMessage(`Run the ${pipelineName} swarm pipeline: ${task}`);
+		},
+	});
+}

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@elyracode/swarm",
+  "version": "0.5.9",
+  "description": "Multi-agent swarm orchestration for Elyra -- automated pipelines with visual progress tracking",
+  "type": "module",
+  "keywords": [
+    "elyra-package",
+    "swarm",
+    "multi-agent",
+    "orchestration",
+    "pipeline"
+  ],
+  "license": "MIT",
+  "author": "Knut W. Horne",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/kwhorne/elyra.git",
+    "directory": "packages/swarm"
+  },
+  "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-swarm/SKILL.md

@@ -0,0 +1,46 @@
+---
+name: elyra-swarm
+description: Multi-agent swarm orchestration. Use when the user asks to build a feature, run a pipeline, or wants multiple agents to collaborate on a task automatically.
+---
+
+# Swarm Orchestration
+
+## When to Use
+
+Use the `swarm` tool when the user asks to:
+- Build a complete feature end-to-end
+- Run a multi-step development pipeline
+- Have multiple agents collaborate automatically
+- Orchestrate planning, implementation, testing, and review
+
+## Available Pipelines
+
+| Pipeline | Stages | Use when |
+|----------|--------|----------|
+| `build` | plan -> code -> test -> review -> fix | Building a new feature or component |
+| `review` | analyze -> correctness -> security -> tests -> synthesize | Deep review of existing code |
+| `refactor` | analyze -> plan -> implement -> verify | Restructuring existing code |
+
+## How It Works
+
+1. User describes the task
+2. Swarm selects a pipeline (or user specifies one)
+3. Each stage runs with focused instructions and passes results to the next
+4. Progress is shown as a visual pipeline in the TUI
+5. Final summary collects all results
+
+## Usage
+
+Natural language:
+```
+Swarm: build user registration with email verification
+Run a review swarm on the payment module
+Refactor the auth system using swarm
+```
+
+Commands:
+```
+/swarm build user registration with email verification
+/swarm review src/payments/
+/swarm refactor the notification system
+```