@elyracode/subagents 0.4.8 → 0.5.0

package/README.md

@@ -37,9 +37,35 @@ Have worker implement this plan, then run reviewer to check it.
 /run reviewer review the changes in the last commit
 /run oracle challenge my current approach
 /parallel reviewer 'check correctness' -> reviewer 'check tests' -> reviewer 'check complexity'
+/build-feature add a wallet system with balance tracking
+/ui-review build a registration form with validation
+/deep-review the authentication system
 /agents
 ```
 
+## Workflows
+
+| Workflow | Command | Steps |
+|----------|---------|-------|
+| **Build Feature** | `/build-feature` | scout -> planner -> oracle -> worker -> reviewer -> worker (fix) |
+| **UI Review** | `/ui-review` | worker (build) -> reviewer (screenshot + visual QA) -> worker (fix) -> reviewer (verify) |
+| **Deep Review** | `/deep-review` | reviewer (correctness) -> reviewer (tests) -> reviewer (security) -> oracle (synthesis) |
+| **Git Review** | `/git-review` | review git diff for correctness, security, tests, code debt, design consistency |
+
+## Git Integration
+
+### Manual review before push
+```
+/git-review
+```
+Reviews your staged and unstaged changes with a go/no-go verdict.
+
+### Automatic pre-push hook
+```
+/setup-git-hook
+```
+Installs a `.git/hooks/pre-push` hook that runs Elyra review automatically before every push. If issues are found, the push is blocked. Skip with `git push --no-verify`.
+
 ### Recommended workflow
 ```
 scout -> planner -> worker -> reviewer -> worker (fixes)

package/extensions/index.ts

@@ -170,6 +170,141 @@ export default function (elyra: ExtensionAPI): void {
 			ctx.ui.notify(`Available subagents:\n${agentList}`);
 		},
 	});
+
+	// -- Tool: orchestrate_workflow --
+	elyra.registerTool({
+		name: "orchestrate_workflow",
+		label: "Orchestrate Multi-Agent Workflow",
+		description:
+			"Run a predefined multi-agent workflow. Available workflows: " +
+			"'build-feature' (scout -> planner -> worker -> reviewer -> fix), " +
+			"'ui-review' (worker builds UI, reviewer screenshots and checks visual quality + accessibility), " +
+			"'deep-review' (parallel reviewers for correctness, tests, security, then synthesis). " +
+			"Use this for complex tasks that benefit from structured multi-agent orchestration.",
+		parameters: Type.Object({
+			workflow: Type.Union(
+				[Type.Literal("build-feature"), Type.Literal("ui-review"), Type.Literal("deep-review")],
+				{ description: "The workflow to run" },
+			),
+			task: Type.String({ description: "Description of the feature or task" }),
+		}),
+		execute: async (_toolCallId, params) => {
+			const workflow = WORKFLOWS[params.workflow];
+			if (!workflow) {
+				return {
+					content: [{ type: "text", text: `Unknown workflow: ${params.workflow}` }],
+					details: {},
+				};
+			}
+
+			const instructions = workflow.steps.map((step, i) => {
+				const agent = BUILTIN_AGENTS[step.agent];
+				const agentDesc = agent ? `(${agent.description})` : "";
+				const readOnly = agent?.readOnly ? " [READ-ONLY]" : "";
+				const stepTask = step.task.replace("{task}", params.task).replace("{previous}", "the previous step's output");
+				return `### Step ${i + 1}: ${step.agent}${readOnly} ${agentDesc}\n${stepTask}`;
+			}).join("\n\n");
+
+			return {
+				content: [{
+					type: "text",
+					text: `# Workflow: ${workflow.name}\n\n` +
+						`${workflow.description}\n\n` +
+						`Task: ${params.task}\n\n` +
+						`## Execution Plan\n\n${instructions}\n\n` +
+						`## Rules\n` +
+						`- Execute each step in order\n` +
+						`- Read-only steps must NOT edit files\n` +
+						`- Pass results from each step to the next\n` +
+						`- After the final step, provide a summary of everything done`,
+				}],
+				details: { workflow: params.workflow, steps: workflow.steps.length },
+			};
+		},
+	});
+
+	// -- Command: /build-feature --
+	elyra.registerCommand("build-feature", {
+		description: "Orchestrated feature development: scout -> planner -> worker -> reviewer -> fix",
+		handler: async (args, _ctx) => {
+			if (!args.trim()) {
+				elyra.sendUserMessage("Usage: /build-feature <description>\n\nExample: /build-feature add a wallet system with balance tracking and transaction history");
+				return;
+			}
+			elyra.sendUserMessage(`Run the build-feature workflow: ${args}`);
+		},
+	});
+
+	// -- Command: /ui-review --
+	elyra.registerCommand("ui-review", {
+		description: "Adversarial UI testing: build UI, then screenshot + visual QA + accessibility check",
+		handler: async (args, _ctx) => {
+			if (!args.trim()) {
+				elyra.sendUserMessage("Usage: /ui-review <description>\n\nExample: /ui-review build a registration form with validation");
+				return;
+			}
+			elyra.sendUserMessage(`Run the ui-review workflow: ${args}`);
+		},
+	});
+
+	// -- Command: /deep-review --
+	elyra.registerCommand("deep-review", {
+		description: "Parallel deep review: correctness + tests + security + synthesis",
+		handler: async (args, _ctx) => {
+			if (!args.trim()) {
+				elyra.sendUserMessage("Usage: /deep-review <what to review>\n\nExample: /deep-review the authentication system");
+				return;
+			}
+			elyra.sendUserMessage(`Run the deep-review workflow: ${args}`);
+		},
+	});
+
+	// -- Command: /git-review --
+	elyra.registerCommand("git-review", {
+		description: "Review staged/uncommitted changes before push. Use as a pre-push quality gate.",
+		handler: async (_args, _ctx) => {
+			elyra.sendUserMessage(
+				"Run the git-review workflow on my current changes. " +
+				"Get the git diff of staged and unstaged changes, then review for: " +
+				"correctness, security issues, missing tests, code debt (TODO/FIXME), " +
+				"and Tailwind design consistency (if UI files changed). " +
+				"If design_system_check is available, run it on modified frontend files. " +
+				"Summarize findings as a go/no-go for pushing.",
+			);
+		},
+	});
+
+	// -- Command: /setup-git-hook --
+	elyra.registerCommand("setup-git-hook", {
+		description: "Install a git pre-push hook that runs elyra review",
+		handler: async (_args, ctx) => {
+			const hookScript = `#!/bin/sh
+# Elyra pre-push review hook
+# Runs a quick code review before pushing
+
+echo "Running Elyra pre-push review..."
+elyra -p "Review the git diff for this push. Run: git diff @{push}.. and analyze the changes. Check for: bugs, security issues, missing tests, code debt. Output a go/no-go verdict. If no-go, exit with code 1."
+ELYRA_EXIT=$?
+
+if [ $ELYRA_EXIT -ne 0 ]; then
+    echo "Elyra review found issues. Push blocked."
+    echo "Run 'elyra' to fix the issues, or 'git push --no-verify' to skip."
+    exit 1
+fi
+
+echo "Elyra review passed."
+exit 0
+`;
+
+			elyra.sendUserMessage(
+				"Set up the Elyra pre-push git hook. Write this script to `.git/hooks/pre-push` and make it executable:\n\n" +
+				"```bash\n" + hookScript + "```\n\n" +
+				"Commands:\n" +
+				"```bash\nmkdir -p .git/hooks\n" +
+				"# Write the hook file\nchmod +x .git/hooks/pre-push\n```",
+			);
+		},
+	});
 }
 
 function formatSubagentPrompt(agent: AgentDefinition, task: string, context?: string): string {
@@ -186,3 +321,51 @@ function formatSubagentPrompt(agent: AgentDefinition, task: string, context?: st
 
 	return parts.join("\n");
 }
+
+// -- Workflow Definitions --
+
+interface WorkflowStep {
+	agent: string;
+	task: string;
+}
+
+interface Workflow {
+	name: string;
+	description: string;
+	steps: WorkflowStep[];
+}
+
+const WORKFLOWS: Record<string, Workflow> = {
+	"build-feature": {
+		name: "Build Feature",
+		description: "Full orchestrated feature development: understand the codebase, plan, implement, review, and fix.",
+		steps: [
+			{ agent: "scout", task: "Analyze the codebase to understand the existing architecture, relevant files, data models, and how {task} should fit in. Report file paths, patterns, and risks." },
+			{ agent: "planner", task: "Based on the scout's findings, create a detailed implementation plan for {task}. Include file paths, function signatures, database changes, and test strategy." },
+			{ agent: "oracle", task: "Review the planner's implementation plan for {task}. Challenge assumptions, identify risks, edge cases, and security concerns. Recommend the safest approach." },
+			{ agent: "worker", task: "Implement {task} following the approved plan. Edit files, create migrations, write code. Validate changes compile and make sense." },
+			{ agent: "reviewer", task: "Review the worker's implementation of {task}. Check correctness, tests, security, simplicity. List issues as critical/warning/suggestion." },
+			{ agent: "worker", task: "Fix the issues found by the reviewer. Apply only the changes that are critical or clearly beneficial." },
+		],
+	},
+	"ui-review": {
+		name: "Adversarial UI Review",
+		description: "Build UI, then visually inspect it with screenshots and check for accessibility, design consistency, and responsive issues.",
+		steps: [
+			{ agent: "worker", task: "Build the UI for {task}. Use the project's component library and Tailwind CSS. Make it responsive and accessible." },
+			{ agent: "reviewer", task: "Review the UI code for {task}. If design_preview or screenshot_url tools are available, use them to visually inspect the result. Check: visual alignment, spacing consistency, color contrast (WCAG), responsive layout (test mobile viewport), hover/focus states, dark mode support. If design_system_check is available, run it on the modified files. Report visual issues with specific Tailwind class fixes." },
+			{ agent: "worker", task: "Fix the visual and accessibility issues found by the reviewer. Apply the Tailwind class changes recommended." },
+			{ agent: "reviewer", task: "Final visual check of {task}. Verify all issues are resolved. Use screenshot_url if available to confirm." },
+		],
+	},
+	"deep-review": {
+		name: "Deep Parallel Review",
+		description: "Run three focused review passes in sequence, then synthesize findings.",
+		steps: [
+			{ agent: "reviewer", task: "CORRECTNESS REVIEW of {task}: Focus exclusively on logical correctness, data handling, error handling, and edge cases. Ignore style and tests." },
+			{ agent: "reviewer", task: "TEST REVIEW of {task}: Focus exclusively on test coverage, missing test cases, test quality, and edge case testing. Ignore implementation style." },
+			{ agent: "reviewer", task: "SECURITY REVIEW of {task}: Focus exclusively on security: SQL injection, XSS, CSRF, auth bypasses, data leaks, insecure defaults, input validation. Ignore style and tests." },
+			{ agent: "oracle", task: "Synthesize all three review reports for {task}. Prioritize findings by impact. Create a single actionable fix list ordered by severity. Recommend which fixes to apply now vs later." },
+		],
+	},
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elyracode/subagents",
-  "version": "0.4.8",
+  "version": "0.5.0",
     "description": "Elyra extension for subagent delegation -- scout, reviewer, planner, worker, oracle, and parallel execution",
   "type": "module",
   "keywords": ["elyra-package", "subagents", "delegation", "multi-agent", "parallel", "code-review"],