@dragonflymcp/plugin 1.0.0

package/templates/synchronizations/archive/test-driven.yaml.template

@@ -0,0 +1,291 @@
+# Test-Driven Development Synchronization Rules
+# Enables test-first development and continuous test verification
+#
+# Based on research:
+# - DPAI Arena: Full test generation evaluation
+# - QualityFlow: Generate tests → verify → execute → repair cycle
+# - 35% reduction in rework with test-first approach
+
+synchronizations:
+  # Generate tests after architecture is complete (TDD mode)
+  - id: "arch-to-test-generation"
+    description: "Generate test specs from architecture before implementation"
+    when:
+      concept: "architecture"
+      action: "design"
+      status: "completed"
+    where:
+      query: "architecture.development_mode == 'tdd' OR project.default_mode == 'tdd'"
+    then:
+      - concept: "test-generator"
+        action: "generate_unit_tests"
+        model: "sonnet"
+        inputs:
+          specification: "${architecture.component_specs}"
+          language: "${architecture.language}"
+          coverageTarget: 80
+
+    slo_expectations:
+      expected_duration_ms: 5000
+      max_duration_ms: 30000
+      expected_cost_usd: 0.001
+      max_cost_usd: 0.003
+      success_rate_target: 0.95
+      on_timeout:
+        action: "warn"
+        continue: true
+      on_mcp_unavailable:
+        action: "skip"
+        fallback: "Manual test creation needed"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "TDD: Generate tests before implementation"
+
+  # Run tests after implementation to verify
+  - id: "impl-to-test-run"
+    description: "Run tests after implementation to verify correctness"
+    when:
+      concept: "implementation"
+      action: "generate"
+      status: "completed"
+    then:
+      - concept: "test-generator"
+        action: "run_tests"
+        model: "sonnet"
+        inputs:
+          coverage: true
+          timeout: 120000
+
+    slo_expectations:
+      expected_duration_ms: 10000
+      max_duration_ms: 120000
+      expected_cost_usd: 0.0005
+      max_cost_usd: 0.002
+      success_rate_target: 0.90
+      on_timeout:
+        action: "warn"
+        message: "Test run timed out"
+      on_failure:
+        action: "escalate"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Verify implementation passes tests"
+
+  # Handle test failures - generate repair suggestions
+  - id: "test-failure-to-repair"
+    description: "When tests fail, analyze and suggest repairs"
+    when:
+      concept: "test-generator"
+      action: "run_tests"
+      status: "completed"
+    where:
+      query: "test_results.failed > 0"
+    then:
+      - concept: "execution-loop"
+        action: "self_debug"
+        model: "sonnet"
+        inputs:
+          code: "${implementation.code}"
+          error: "${test_results.failures}"
+          language: "${implementation.language}"
+
+    slo_expectations:
+      expected_duration_ms: 15000
+      max_duration_ms: 60000
+      expected_cost_usd: 0.002
+      max_cost_usd: 0.005
+      success_rate_target: 0.85
+      on_timeout:
+        action: "escalate"
+        message: "Self-debug timed out"
+      on_mcp_unavailable:
+        action: "fallback"
+        fallback_rule: "quality-tests-failed"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Diagnose test failures for repair"
+
+  # Analyze coverage after successful tests
+  - id: "test-success-to-coverage"
+    description: "Analyze coverage when tests pass"
+    when:
+      concept: "test-generator"
+      action: "run_tests"
+      status: "completed"
+    where:
+      query: "test_results.failed == 0"
+    then:
+      - concept: "test-generator"
+        action: "analyze_coverage"
+        model: "sonnet"
+
+    slo_expectations:
+      expected_duration_ms: 3000
+      max_duration_ms: 15000
+      expected_cost_usd: 0.0005
+      max_cost_usd: 0.002
+      success_rate_target: 0.95
+      on_timeout:
+        action: "skip"
+        fallback: "Skip coverage analysis"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Check test coverage after tests pass"
+
+  # Flag low coverage for additional test generation
+  - id: "low-coverage-to-more-tests"
+    description: "Generate more tests when coverage is below target"
+    when:
+      concept: "test-generator"
+      action: "analyze_coverage"
+      status: "completed"
+    where:
+      query: "coverage.totalCoverage < 80 AND coverage.gaps.length > 0"
+    then:
+      - concept: "test-generator"
+        action: "suggest_tests"
+        model: "sonnet"
+        inputs:
+          files: "${coverage.gaps.map(g => g.file)}"
+          language: "${implementation.language}"
+
+    slo_expectations:
+      expected_duration_ms: 5000
+      max_duration_ms: 20000
+      expected_cost_usd: 0.001
+      max_cost_usd: 0.003
+      success_rate_target: 0.90
+      on_timeout:
+        action: "warn"
+        continue: true
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Coverage below target - suggest additional tests"
+
+  # Find untested files during quality review
+  - id: "quality-to-untested-check"
+    description: "Check for untested files during quality review"
+    when:
+      concept: "quality"
+      action: "review"
+      status: "starting"
+    then:
+      - concept: "test-generator"
+        action: "find_untested_files"
+        model: "sonnet"
+
+    slo_expectations:
+      expected_duration_ms: 2000
+      max_duration_ms: 10000
+      expected_cost_usd: 0.0005
+      max_cost_usd: 0.001
+      success_rate_target: 0.95
+      on_timeout:
+        action: "skip"
+        fallback: "Skip untested file check"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Identify untested files during quality review"
+
+  # Block quality approval if critical files are untested
+  - id: "untested-files-block"
+    description: "Warn if critical implementation files lack tests"
+    when:
+      concept: "test-generator"
+      action: "find_untested_files"
+      status: "completed"
+    where:
+      query: "untested_files.count > 0 AND untested_files.files.some(f => f.source.includes(implementation.main_file))"
+    then:
+      - concept: "quality"
+        action: "add_finding"
+        model: "sonnet"
+        inputs:
+          severity: "warning"
+          finding: "Main implementation file lacks test coverage"
+          recommendation: "Add tests for ${implementation.main_file}"
+
+    slo_expectations:
+      expected_duration_ms: 1000
+      max_duration_ms: 5000
+      expected_cost_usd: 0.0002
+      max_cost_usd: 0.001
+      success_rate_target: 0.99
+      on_timeout:
+        action: "warn"
+        continue: true
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Critical file missing tests"
+
+  # Continuous testing during iterative refinement
+  - id: "refinement-with-tests"
+    description: "Re-run tests after each refinement pass"
+    when:
+      concept: "execution-loop"
+      action: "iterative_refine"
+      status: "completed"
+    then:
+      - concept: "test-generator"
+        action: "run_tests"
+        model: "sonnet"
+        inputs:
+          coverage: false  # Quick run, no coverage
+          timeout: 60000   # Shorter timeout
+
+    slo_expectations:
+      expected_duration_ms: 5000
+      max_duration_ms: 60000
+      expected_cost_usd: 0.0005
+      max_cost_usd: 0.002
+      success_rate_target: 0.90
+      on_timeout:
+        action: "warn"
+        continue: true
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Verify refinement didn't break tests"
+
+  # Generate integration tests for complex features
+  - id: "complex-feature-integration-tests"
+    description: "Generate integration tests for complex multi-component features"
+    when:
+      concept: "architecture"
+      action: "design"
+      status: "completed"
+    where:
+      query: "architecture.components.length > 3 OR architecture.complexity == 'high'"
+    then:
+      - concept: "test-generator"
+        action: "generate_integration_tests"
+        model: "sonnet"
+        inputs:
+          entryPoint: "${architecture.main_entry_point}"
+          dependencies: "${architecture.external_dependencies}"
+          scenarios: "${architecture.key_scenarios}"
+          language: "${architecture.language}"
+
+    slo_expectations:
+      expected_duration_ms: 8000
+      max_duration_ms: 45000
+      expected_cost_usd: 0.002
+      max_cost_usd: 0.005
+      success_rate_target: 0.90
+      on_timeout:
+        action: "warn"
+        continue: true
+      on_mcp_unavailable:
+        action: "skip"
+        fallback: "Manual integration test creation needed"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Complex feature requires integration tests"

package/templates/synchronizations/archive/tool-routing.yaml.template

@@ -0,0 +1,326 @@
+# Tool Routing Synchronization Rules
+# Enables dynamic tool selection and learning from outcomes
+#
+# Based on research:
+# - DyLAN: 25% accuracy improvement with dynamic selection
+# - Natural Language Tools: 18.4% improvement in tool calling
+# - MetaTools: Meta-execution for tool reasoning
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# Global Defaults for Tool Routing
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+version: "1.0.0"
+
+slo_defaults:
+  expected_duration_ms: 2000
+  max_duration_ms: 10000
+  expected_cost_usd: 0.0002
+  max_cost_usd: 0.001
+  expected_context_tokens: 500
+  success_rate_target: 0.95
+  on_timeout:
+    action: "skip"
+    fallback: "Use default tool selection"
+
+synchronizations:
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  # Pre-Task Tool Selection
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  - id: "task-start-routing"
+    description: "Select optimal tools before starting a task"
+    when:
+      event: "task_started"
+    then:
+      - concept: "tool-router"
+        action: "select_tools"
+        model: "sonnet"
+        inputs:
+          task_description: "${task.description}"
+          available_tools: "${system.available_tools}"
+          context: "${context.summary}"
+
+    slo_expectations:
+      expected_duration_ms: 1500
+      max_duration_ms: 5000
+      expected_cost_usd: 0.0002
+      max_cost_usd: 0.0005
+      on_timeout:
+        action: "skip"
+        fallback: "Use default tool set"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Pre-task tool optimization"
+      category: "intelligence"
+
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  # Learning from Outcomes
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  - id: "task-success-to-learning"
+    description: "Learn from successful tool usage"
+    when:
+      event: "task_completed"
+    where:
+      query: "task.status == 'success'"
+    then:
+      - concept: "tool-router"
+        action: "learn_from_outcome"
+        model: "sonnet"
+        inputs:
+          task_id: "${task.id}"
+          task_type: "${task.type}"
+          tools_used: "${task.tools_used}"
+          tools_suggested: "${task.tools_suggested}"
+          outcome: "success"
+          metrics:
+            duration: "${task.duration}"
+            tokens: "${task.tokens_used}"
+
+    slo_expectations:
+      expected_duration_ms: 1000
+      max_duration_ms: 5000
+      expected_cost_usd: 0.0001
+      max_cost_usd: 0.0003
+      on_timeout:
+        action: "skip"
+        fallback: "Learning deferred"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Learning from successful tool usage"
+      category: "learning"
+
+  - id: "task-failure-to-learning"
+    description: "Learn from failed tool usage"
+    when:
+      event: "task_completed"
+    where:
+      query: "task.status == 'failure'"
+    then:
+      - concept: "tool-router"
+        action: "learn_from_outcome"
+        model: "sonnet"
+        inputs:
+          task_id: "${task.id}"
+          task_type: "${task.type}"
+          tools_used: "${task.tools_used}"
+          tools_suggested: "${task.tools_suggested}"
+          outcome: "failure"
+          error: "${task.error}"
+
+    slo_expectations:
+      expected_duration_ms: 1500
+      max_duration_ms: 5000
+      expected_cost_usd: 0.0002
+      max_cost_usd: 0.0005
+      on_timeout:
+        action: "skip"
+        fallback: "Failure learning deferred"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Learning from tool failures"
+      category: "learning"
+
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  # Error Recovery
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  - id: "tool-failure-to-alternative"
+    description: "Suggest alternative tools when one fails"
+    when:
+      event: "tool_call_failed"
+    then:
+      - concept: "tool-router"
+        action: "suggest_tool_for_error"
+        model: "sonnet"
+        inputs:
+          failed_tool: "${tool.name}"
+          error_message: "${tool.error}"
+          task_context: "${task.current_context}"
+
+    slo_expectations:
+      expected_duration_ms: 1000
+      max_duration_ms: 3000
+      expected_cost_usd: 0.0001
+      max_cost_usd: 0.0003
+      on_timeout:
+        action: "escalate"
+        message: "Cannot find alternative tool"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Tool failed - finding alternative"
+      category: "recovery"
+
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  # Context-Specific Routing
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  - id: "impl-pre-routing"
+    description: "Select best tools for implementation"
+    when:
+      concept: "implementation"
+      action: "generate"
+      status: "starting"
+    then:
+      - concept: "tool-router"
+        action: "select_tools"
+        model: "sonnet"
+        inputs:
+          task_description: "Implement ${implementation.component}"
+          task_type: "implementation"
+          context: "${architecture.design}"
+
+    slo_expectations:
+      expected_duration_ms: 2000
+      max_duration_ms: 8000
+      expected_cost_usd: 0.0003
+      max_cost_usd: 0.001
+      on_timeout:
+        action: "skip"
+        fallback: "Use default implementation tools"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Optimizing tools for implementation"
+      category: "intelligence"
+
+  - id: "search-pre-routing"
+    description: "Select best search tools based on query"
+    when:
+      event: "search_requested"
+    then:
+      - concept: "tool-router"
+        action: "select_tools"
+        model: "sonnet"
+        inputs:
+          task_description: "${search.query}"
+          task_type: "code_search"
+          constraints:
+            prefer_speed: "${search.is_interactive}"
+
+    slo_expectations:
+      expected_duration_ms: 500
+      max_duration_ms: 2000
+      expected_cost_usd: 0.0001
+      max_cost_usd: 0.0002
+      on_timeout:
+        action: "skip"
+        fallback: "Use Grep for search"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Optimizing search tool selection"
+      category: "intelligence"
+
+  - id: "debug-pre-routing"
+    description: "Select best debugging approach"
+    when:
+      concept: "execution-loop"
+      action: "self_debug"
+      status: "starting"
+    then:
+      - concept: "tool-router"
+        action: "select_tools"
+        model: "sonnet"
+        inputs:
+          task_description: "Debug ${error.type}: ${error.message}"
+          task_type: "debugging"
+          context:
+            error_type: "${error.type}"
+            file: "${error.file}"
+            language: "${error.language}"
+
+    slo_expectations:
+      expected_duration_ms: 1500
+      max_duration_ms: 5000
+      expected_cost_usd: 0.0002
+      max_cost_usd: 0.0005
+      on_timeout:
+        action: "skip"
+        fallback: "Use standard debug approach"
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Selecting debugging approach"
+      category: "intelligence"
+
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  # Periodic Optimization
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  - id: "periodic-routing-review"
+    description: "Review and optimize routing rules periodically"
+    when:
+      schedule: "daily"
+    where:
+      query: "routing.task_count_24h > 10"
+    then:
+      - concept: "tool-router"
+        action: "get_tool_stats"
+        model: "sonnet"
+        inputs:
+          timeframe: "24h"
+      - concept: "retrospective"
+        action: "analyze_tool_usage"
+        model: "sonnet"
+        inputs:
+          stats: "${tool_router.stats}"
+
+    slo_expectations:
+      expected_duration_ms: 5000
+      max_duration_ms: 30000
+      expected_cost_usd: 0.0005
+      max_cost_usd: 0.002
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Daily routing optimization"
+      category: "optimization"
+
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+  # Apply Recommendations
+  # ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+  - id: "apply-routing-suggestion"
+    description: "Apply tool router suggestions to current task"
+    when:
+      concept: "tool-router"
+      action: "select_tools"
+      status: "completed"
+    then:
+      - concept: "task"
+        action: "set_tool_preferences"
+        model: "sonnet"
+        inputs:
+          recommended_tools: "${routing.recommended_tools}"
+          sequence: "${routing.sequence}"
+          fallbacks: "${routing.fallbacks}"
+
+    slo_expectations:
+      expected_duration_ms: 500
+      max_duration_ms: 2000
+      expected_cost_usd: 0.0001
+      max_cost_usd: 0.0002
+
+    provenance:
+      flow_id: "${flow.id}"
+      reason: "Applying tool routing recommendations"
+      category: "execution"
+
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+# Tool Routing Summary
+# ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+#
+# This synchronization file enables:
+# - Pre-task tool optimization based on task type
+# - Learning from successful and failed tool usage
+# - Automatic fallback to alternatives on failure
+# - Context-specific routing (implementation, search, debug)
+# - Periodic analysis and optimization
+#
+# Expected improvement: 25% accuracy, 18% efficiency
+# Cost per routing decision: ~$0.0002