Skip to content

armgit / ruflo

Public Imported from GitHub
0

🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated

checkpoint: File edit:

rUv9d3a90d7a6a8
diff --git a/v3/@claude-flow/shared/__tests__/hooks/task-hooks.test.ts b/v3/@claude-flow/shared/__tests__/hooks/task-hooks.test.ts
new file mode 100644
index 0000000000..f8260b5e89
--- /dev/null
+++ b/v3/@claude-flow/shared/__tests__/hooks/task-hooks.test.ts
@@ -0,0 +1,193 @@
+/**
+ * V3 Task Hooks Tests
+ *
+ * Tests for pre-task and post-task hook functionality.
+ *
+ * @module v3/shared/hooks/__tests__/task-hooks.test
+ */
+
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import {
+ createHookRegistry,
+ createTaskHooksManager,
+ TaskHooksManager,
+ HookRegistry,
+ HookEvent,
+} from '../../src/hooks/index.js';
+
+describe('TaskHooksManager', () => {
+ let registry: HookRegistry;
+ let taskManager: TaskHooksManager;
+
+ beforeEach(() => {
+ registry = createHookRegistry();
+ taskManager = createTaskHooksManager(registry);
+ });
+
+ describe('pre-task hook', () => {
+ it('should register pre-task hook on creation', () => {
+ const hooks = registry.getHandlers(HookEvent.PreTaskExecute);
+ expect(hooks.length).toBeGreaterThan(0);
+ expect(hooks.some(h => h.name === 'task-hooks:pre-task')).toBe(true);
+ });
+
+ it('should analyze task and suggest agents for coding task', async () => {
+ const result = await taskManager.executePreTask(
+ 'task-123',
+ 'Implement user authentication feature'
+ );
+
+ expect(result.success).toBe(true);
+ expect(result.suggestedAgents).toBeDefined();
+ expect(result.suggestedAgents!.length).toBeGreaterThan(0);
+ expect(result.suggestedAgents![0].type).toBe('coder');
+ expect(result.suggestedAgents![0].confidence).toBeGreaterThan(0);
+ });
+
+ it('should suggest security-architect for security tasks', async () => {
+ const result = await taskManager.executePreTask(
+ 'task-456',
+ 'Fix security vulnerability in authentication'
+ );
+
+ expect(result.success).toBe(true);
+ expect(result.suggestedAgents).toBeDefined();
+ const securityAgent = result.suggestedAgents!.find(a => a.type === 'security-architect');
+ expect(securityAgent).toBeDefined();
+ });
+
+ it('should suggest tester for test-related tasks', async () => {
+ const result = await taskManager.executePreTask(
+ 'task-789',
+ 'Write unit tests for user service'
+ );
+
+ expect(result.success).toBe(true);
+ expect(result.suggestedAgents).toBeDefined();
+ const testerAgent = result.suggestedAgents!.find(a => a.type === 'tester');
+ expect(testerAgent).toBeDefined();
+ });
+
+ it('should estimate complexity based on task description', async () => {
+ // Simple task
+ const simpleResult = await taskManager.executePreTask(
+ 'task-simple',
+ 'Fix typo in readme'
+ );
+ expect(simpleResult.complexity).toBe('low');
+
+ // Complex task
+ const complexResult = await taskManager.executePreTask(
+ 'task-complex',
+ 'Refactor and redesign the entire authentication system with multiple OAuth providers'
+ );
+ expect(complexResult.complexity).toBe('high');
+ });
+
+ it('should detect risks in task description', async () => {
+ const result = await taskManager.executePreTask(
+ 'task-risky',
+ 'Delete old data from production database'
+ );
+
+ expect(result.risks).toBeDefined();
+ expect(result.risks!.length).toBeGreaterThan(0);
+ expect(result.risks!.some(r => r.includes('production'))).toBe(true);
+ });
+
+ it('should track active tasks', async () => {
+ await taskManager.executePreTask('task-1', 'Task 1');
+ await taskManager.executePreTask('task-2', 'Task 2');
+
+ const activeTasks = taskManager.getActiveTasks();
+ expect(activeTasks.size).toBe(2);
+ expect(activeTasks.has('task-1')).toBe(true);
+ expect(activeTasks.has('task-2')).toBe(true);
+ });
+
+ it('should provide recommendations for high complexity tasks', async () => {
+ const result = await taskManager.executePreTask(
+ 'task-high-complexity',
+ 'Implement complex distributed system with multiple services'
+ );
+
+ expect(result.recommendations).toBeDefined();
+ expect(result.recommendations!.length).toBeGreaterThan(0);
+ });
+ });
+
+ describe('post-task hook', () => {
+ it('should register post-task hook on creation', () => {
+ const hooks = registry.getHandlers(HookEvent.PostTaskExecute);
+ expect(hooks.length).toBeGreaterThan(0);
+ expect(hooks.some(h => h.name === 'task-hooks:post-task')).toBe(true);
+ });
+
+ it('should record successful task outcome', async () => {
+ // First start the task
+ await taskManager.executePreTask('task-success', 'Test task');
+
+ // Then complete it
+ const result = await taskManager.executePostTask('task-success', true);
+
+ expect(result.success).toBe(true);
+ expect(result.outcome).toBeDefined();
+ expect(result.outcome!.success).toBe(true);
+ expect(result.outcome!.duration).toBeGreaterThanOrEqual(0);
+ });
+
+ it('should record failed task outcome', async () => {
+ await taskManager.executePreTask('task-failed', 'Test task');
+
+ const result = await taskManager.executePostTask('task-failed', false, {
+ error: 'Test failed due to timeout',
+ });
+
+ expect(result.success).toBe(true);
+ expect(result.outcome).toBeDefined();
+ expect(result.outcome!.success).toBe(false);
+ });
+
+ it('should create learning trajectory', async () => {
+ await taskManager.executePreTask('task-learn', 'Test task');
+ const result = await taskManager.executePostTask('task-learn', true);
+
+ expect(result.trajectoryId).toBeDefined();
+ expect(result.trajectoryId).toContain('trajectory-');
+ });
+
+ it('should track learning updates', async () => {
+ await taskManager.executePreTask('task-updates', 'Test task');
+ const result = await taskManager.executePostTask('task-updates', true);
+
+ expect(result.learningUpdates).toBeDefined();
+ expect(result.learningUpdates!.trajectoriesRecorded).toBe(1);
+ });
+
+ it('should remove task from active tasks after completion', async () => {
+ await taskManager.executePreTask('task-cleanup', 'Test task');
+ expect(taskManager.getActiveTasks().has('task-cleanup')).toBe(true);
+
+ await taskManager.executePostTask('task-cleanup', true);
+ expect(taskManager.getActiveTasks().has('task-cleanup')).toBe(false);
+ });
+
+ it('should handle post-task without pre-task gracefully', async () => {
+ const result = await taskManager.executePostTask('task-no-pre', true);
+
+ expect(result.success).toBe(true);
+ expect(result.outcome).toBeDefined();
+ });
+ });
+
+ describe('clearActiveTasks', () => {
+ it('should clear all active tasks', async () => {
+ await taskManager.executePreTask('task-1', 'Task 1');
+ await taskManager.executePreTask('task-2', 'Task 2');
+ expect(taskManager.getActiveTasks().size).toBe(2);
+
+ taskManager.clearActiveTasks();
+ expect(taskManager.getActiveTasks().size).toBe(0);
+ });
+ });
+});
diff --git a/v3/@claude-flow/testing/src/v2-compat/index.ts b/v3/@claude-flow/testing/src/v2-compat/index.ts
new file mode 100644
index 0000000000..85198b6022
--- /dev/null
+++ b/v3/@claude-flow/testing/src/v2-compat/index.ts
@@ -0,0 +1,58 @@
+/**
+ * V2 Compatibility Testing Module
+ *
+ * Provides validation framework for testing V3 against V2 capabilities.
+ * Ensures backward compatibility for CLI commands, MCP tools, hooks, and API interfaces.
+ *
+ * @module v3/testing/v2-compat
+ *
+ * @example
+ * ```typescript
+ * import {
+ * V2CompatibilityValidator,
+ * generateCompatibilityReport,
+ * V2_CLI_COMMANDS,
+ * V2_MCP_TOOLS,
+ * V2_HOOKS,
+ * V2_API_INTERFACES
+ * } from '@claude-flow/testing/v2-compat';
+ *
+ * // Run full validation
+ * const validator = new V2CompatibilityValidator({ verbose: true });
+ * const report = await validator.runFullValidation();
+ *
+ * // Generate markdown report
+ * const markdown = generateCompatibilityReport(report);
+ * console.log(markdown);
+ *
+ * // Access individual validation results
+ * console.log(`CLI: ${report.cli.passedChecks}/${report.cli.totalChecks} passed`);
+ * console.log(`MCP: ${report.mcp.passedChecks}/${report.mcp.totalChecks} passed`);
+ * console.log(`Hooks: ${report.hooks.passedChecks}/${report.hooks.totalChecks} passed`);
+ * console.log(`API: ${report.api.passedChecks}/${report.api.totalChecks} passed`);
+ * ```
+ */
+
+// Main validator class and report generator
+export {
+ V2CompatibilityValidator,
+ generateCompatibilityReport,
+ type ValidationCheck,
+ type ValidationResult,
+ type FullValidationReport,
+} from './compatibility-validator.js';
+
+// V2 definitions
+export {
+ V2_CLI_COMMANDS,
+ V2_MCP_TOOLS,
+ V2_HOOKS,
+ V2_API_INTERFACES,
+ type V2CLICommand,
+ type V2MCPTool,
+ type V2Hook,
+ type V2APIInterface,
+} from './compatibility-validator.js';
+
+// Re-export test utilities for custom test implementations
+export { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
diff --git a/v3/mcp/tools/task-tools.ts b/v3/mcp/tools/task-tools.ts
index 52190a8629..dbdfa4ca03 100644
--- a/v3/mcp/tools/task-tools.ts
+++ b/v3/mcp/tools/task-tools.ts
@@ -771,7 +771,7 @@ async function handleTaskDependencies(
switch (input.action) {
case 'add':
if (input.dependencies) {
- task.dependencies = [...new Set([...task.dependencies, ...input.dependencies])];
+ task.dependencies = Array.from(new Set([...task.dependencies, ...input.dependencies]));
task.updatedAt = updatedAt;
}
break;