@probelabs/visor 0.1.106 → 0.1.111

package/dist/examples/memory-exec-js.yaml

@@ -0,0 +1,247 @@
+# Script Example: Complex Logic with Memory
+#
+# This example demonstrates using the script provider to perform
+# complex data analysis and manipulation with full JavaScript support.
+
+version: "1.0"
+
+memory:
+  storage: memory
+  namespace: default
+
+steps:
+  # Simulate multiple validation checks
+  check-security:
+    type: command
+    exec: 'echo ''{"issues": 3, "severity": "high"}'''
+    transform_js: "JSON.parse(output.trim())"
+
+  check-performance:
+    type: command
+    exec: 'echo ''{"issues": 7, "severity": "medium"}'''
+    transform_js: "JSON.parse(output.trim())"
+
+  check-style:
+    type: command
+    exec: 'echo ''{"issues": 15, "severity": "low"}'''
+    transform_js: "JSON.parse(output.trim())"
+
+  # Use script to aggregate and analyze results
+  analyze-all-checks:
+    type: script
+    depends_on: [check-security, check-performance, check-style]
+    content: |
+      // Collect all check results
+      const checks = {
+        security: outputs['check-security'],
+        performance: outputs['check-performance'],
+        style: outputs['check-style']
+      };
+
+      // Initialize analysis object
+      const analysis = {
+        checks: {},
+        totals: {
+          critical: 0,
+          high: 0,
+          medium: 0,
+          low: 0,
+          total: 0
+        },
+        summary: {
+          passed: 0,
+          failed: 0,
+          total: 3
+        }
+      };
+
+      // Analyze each check
+      for (const [name, result] of Object.entries(checks)) {
+        const issueCount = result.issues || 0;
+        const severity = result.severity || 'low';
+
+        analysis.checks[name] = {
+          issues: issueCount,
+          severity: severity,
+          status: issueCount === 0 ? 'passed' : 'failed'
+        };
+
+        // Update totals
+        analysis.totals.total += issueCount;
+        analysis.totals[severity] = (analysis.totals[severity] || 0) + issueCount;
+
+        // Update summary
+        if (issueCount === 0) {
+          analysis.summary.passed++;
+        } else {
+          analysis.summary.failed++;
+        }
+      }
+
+      // Calculate risk score (0-100, higher is worse)
+      const riskScore = Math.min(100,
+        (analysis.totals.critical * 20) +
+        (analysis.totals.high * 10) +
+        (analysis.totals.medium * 5) +
+        (analysis.totals.low * 1)
+      );
+
+      analysis.riskScore = riskScore;
+
+      // Determine overall status
+      let overallStatus;
+      if (analysis.totals.critical > 0 || analysis.totals.high > 5) {
+        overallStatus = 'critical';
+      } else if (analysis.totals.high > 0 || analysis.totals.medium > 10) {
+        overallStatus = 'warning';
+      } else if (analysis.totals.total > 20) {
+        overallStatus = 'attention';
+      } else {
+        overallStatus = 'ok';
+      }
+
+      analysis.overallStatus = overallStatus;
+
+      // Store in memory for other checks
+      memory.set('analysis', analysis);
+      memory.set('risk_score', riskScore);
+      memory.set('overall_status', overallStatus);
+
+      // Create recommendations based on analysis
+      const recommendations = [];
+      if (analysis.totals.critical > 0) {
+        recommendations.push('Address all critical security issues immediately');
+      }
+      if (analysis.totals.high >= 3) {
+        recommendations.push(`Fix ${analysis.totals.high} high-severity issues`);
+      }
+      if (analysis.totals.medium > 5) {
+        recommendations.push('Consider addressing medium-severity issues');
+      }
+      if (analysis.totals.low > 20) {
+        recommendations.push('Clean up style issues in a follow-up PR');
+      }
+
+      memory.set('recommendations', recommendations);
+
+      // Return summary
+      return {
+        riskScore,
+        overallStatus,
+        totalIssues: analysis.totals.total,
+        recommendationCount: recommendations.length
+      };
+
+  # Generate detailed report
+  generate-report:
+    type: log
+    depends_on: [analyze-all-checks]
+    message: |
+      {% assign analysis = "analysis" | memory_get %}
+      {% assign recommendations = "recommendations" | memory_get %}
+
+      ## Code Quality Report
+
+      ### Overall Status: {{ analysis.overallStatus | upcase }}
+      **Risk Score:** {{ analysis.riskScore }}/100
+
+      ### Check Results
+      | Check | Issues | Severity | Status |
+      |-------|--------|----------|--------|
+      {% for check in analysis.checks %}
+      | {{ check[0] }} | {{ check[1].issues }} | {{ check[1].severity }} | {{ check[1].status }} |
+      {% endfor %}
+
+      ### Issue Summary
+      - 🔴 Critical: {{ analysis.totals.critical }}
+      - 🟠 High: {{ analysis.totals.high }}
+      - 🟡 Medium: {{ analysis.totals.medium }}
+      - 🟢 Low: {{ analysis.totals.low }}
+      - **Total:** {{ analysis.totals.total }}
+
+      ### Recommendations
+      {% if recommendations.size > 0 %}
+      {% for rec in recommendations %}
+      {{ forloop.index }}. {{ rec }}
+      {% endfor %}
+      {% else %}
+      ✅ No issues found - great job!
+      {% endif %}
+
+  # Calculate trends if previous data exists
+  calculate-trend:
+    type: script
+    depends_on: [analyze-all-checks]
+    content: |
+      const currentScore = memory.get('risk_score');
+
+      // Get previous score (would be from persistent storage in real use)
+      const previousScore = memory.get('previous_risk_score') || currentScore;
+
+      // Calculate trend
+      const diff = currentScore - previousScore;
+      const percentChange = previousScore > 0
+        ? ((diff / previousScore) * 100).toFixed(1)
+        : 0;
+
+      let trend;
+      if (Math.abs(diff) < 5) {
+        trend = 'stable';
+      } else if (diff > 0) {
+        trend = 'worsening';
+      } else {
+        trend = 'improving';
+      }
+
+      const trendData = {
+        current: currentScore,
+        previous: previousScore,
+        diff,
+        percentChange,
+        trend
+      };
+
+      memory.set('trend', trendData);
+
+      // Store current as previous for next run
+      memory.set('previous_risk_score', currentScore);
+
+      return trendData;
+
+  # Report trend
+  report-trend:
+    type: log
+    depends_on: [calculate-trend]
+    message: |
+      {% assign trend = "trend" | memory_get %}
+
+      ### Trend Analysis
+      - Previous Score: {{ trend.previous }}
+      - Current Score: {{ trend.current }}
+      - Change: {% if trend.diff > 0 %}+{% endif %}{{ trend.diff }} ({{ trend.percentChange }}%)
+      - Trend: **{{ trend.trend | upcase }}**
+
+      {% if trend.trend == "improving" %}
+      📈 Code quality is improving!
+      {% elsif trend.trend == "worsening" %}
+      📉 Code quality is declining - attention needed
+      {% else %}
+      ➡️ Code quality remains stable
+      {% endif %}
+
+  # Final check - fail if risk is too high
+  verify-quality-gate:
+    type: noop
+    depends_on: [report-trend]
+    fail_if: |
+      const riskScore = memory.get('risk_score');
+      const overallStatus = memory.get('overall_status');
+
+      // Fail if critical status or risk score > 50
+      return overallStatus === 'critical' || riskScore > 50;
+
+output:
+  pr_comment:
+    format: markdown
+    group_by: check
+    collapse: false

package/dist/examples/memory-namespace-isolation.yaml

@@ -0,0 +1,184 @@
+# Memory Example: Namespace Isolation
+#
+# This example shows how to use namespaces to isolate data
+# for different environments (production, staging, development).
+
+version: "1.0"
+
+memory:
+  storage: file
+  file: ./multi-env-memory.json
+  format: json
+  namespace: production  # Default namespace
+
+steps:
+  # Production environment metrics
+  prod-init-counter:
+    type: memory
+    operation: set
+    key: deploy_count
+    value_js: "(memory.get('deploy_count', 'production') || 0)"
+    namespace: production
+
+  prod-increment:
+    type: memory
+    operation: set
+    key: deploy_count
+    value_js: "memory.get('deploy_count', 'production') + 1"
+    namespace: production
+    depends_on: [prod-init-counter]
+
+  prod-track-time:
+    type: memory
+    operation: set
+    key: last_deploy_time
+    value_js: "new Date().toISOString()"
+    namespace: production
+    depends_on: [prod-increment]
+
+  # Staging environment metrics
+  stage-init-counter:
+    type: memory
+    operation: set
+    key: deploy_count
+    value_js: "(memory.get('deploy_count', 'staging') || 0)"
+    namespace: staging
+
+  stage-increment:
+    type: memory
+    operation: set
+    key: deploy_count
+    value_js: "memory.get('deploy_count', 'staging') + 1"
+    namespace: staging
+    depends_on: [stage-init-counter]
+
+  stage-track-time:
+    type: memory
+    operation: set
+    key: last_deploy_time
+    value_js: "new Date().toISOString()"
+    namespace: staging
+    depends_on: [stage-increment]
+
+  # Development environment metrics
+  dev-init-counter:
+    type: memory
+    operation: set
+    key: deploy_count
+    value_js: "(memory.get('deploy_count', 'development') || 0)"
+    namespace: development
+
+  dev-increment:
+    type: memory
+    operation: set
+    key: deploy_count
+    value_js: "memory.get('deploy_count', 'development') + 1"
+    namespace: development
+    depends_on: [dev-init-counter]
+
+  dev-track-time:
+    type: memory
+    operation: set
+    key: last_deploy_time
+    value_js: "new Date().toISOString()"
+    namespace: development
+    depends_on: [dev-increment]
+
+  # Collect environment-specific errors
+  prod-check:
+    type: command
+    exec: ./scripts/check-production.sh
+    depends_on: [prod-track-time]
+    on_fail:
+      run: [prod-log-error]
+
+  prod-log-error:
+    type: memory
+    operation: append
+    key: errors
+    value: "Production check failed"
+    namespace: production
+
+  stage-check:
+    type: command
+    exec: ./scripts/check-staging.sh
+    depends_on: [stage-track-time]
+    on_fail:
+      run: [stage-log-error]
+
+  stage-log-error:
+    type: memory
+    operation: append
+    key: errors
+    value: "Staging check failed"
+    namespace: staging
+
+  # Report metrics for all environments
+  report-metrics:
+    type: log
+    depends_on: [prod-track-time, stage-track-time, dev-track-time]
+    message: |
+      ## Deployment Metrics
+
+      ### Production
+      - Deploys: {{ "deploy_count" | memory_get: "production" }}
+      - Last Deploy: {{ "last_deploy_time" | memory_get: "production" }}
+      {% assign prod_errors = "errors" | memory_get: "production" %}
+      - Errors: {{ prod_errors.size | default: 0 }}
+
+      ### Staging
+      - Deploys: {{ "deploy_count" | memory_get: "staging" }}
+      - Last Deploy: {{ "last_deploy_time" | memory_get: "staging" }}
+      {% assign stage_errors = "errors" | memory_get: "staging" %}
+      - Errors: {{ stage_errors.size | default: 0 }}
+
+      ### Development
+      - Deploys: {{ "deploy_count" | memory_get: "development" }}
+      - Last Deploy: {{ "last_deploy_time" | memory_get: "development" }}
+
+  # List all namespaces
+  list-namespaces:
+    type: log
+    depends_on: [report-metrics]
+    message: |
+      Active namespaces:
+      {% for ns in memory.listNamespaces() %}
+      - {{ ns }}
+      {% endfor %}
+
+  # Compare environments
+  compare-envs:
+    type: memory
+    operation: set
+    key: comparison
+    value_js: |
+      return {
+        production: memory.get('deploy_count', 'production'),
+        staging: memory.get('deploy_count', 'staging'),
+        development: memory.get('deploy_count', 'development'),
+        total: (memory.get('deploy_count', 'production') || 0) +
+               (memory.get('deploy_count', 'staging') || 0) +
+               (memory.get('deploy_count', 'development') || 0)
+      };
+    depends_on: [list-namespaces]
+
+  # Report comparison
+  report-comparison:
+    type: log
+    depends_on: [compare-envs]
+    message: |
+      {% assign comp = "comparison" | memory_get %}
+      ## Environment Comparison
+
+      | Environment | Deploys |
+      |-------------|---------|
+      | Production  | {{ comp.production }} |
+      | Staging     | {{ comp.staging }} |
+      | Development | {{ comp.development }} |
+      | **Total**   | **{{ comp.total }}** |
+
+output:
+  pr_comment:
+    format: markdown
+    group_by: check
+    collapse: false

package/dist/examples/memory-retry-counter.yaml

@@ -0,0 +1,65 @@
+# Memory Example: Retry Counter with goto
+#
+# This example demonstrates using memory to track retry attempts
+# and implement retry logic with goto routing.
+
+version: "1.0"
+
+memory:
+  storage: memory  # In-memory storage (not persistent)
+  namespace: default
+
+steps:
+  # Initialize retry counter
+  init-retry:
+    type: memory
+    operation: set
+    key: retry_count
+    value: 0
+
+  # Run a test that might fail
+  run-flaky-test:
+    type: command
+    exec: |
+      # Simulate a flaky test (fails 50% of the time)
+      if [ $((RANDOM % 2)) -eq 0 ]; then
+        echo "Test passed!"
+        exit 0
+      else
+        echo "Test failed!"
+        exit 1
+      fi
+    depends_on: [init-retry]
+    on_fail:
+      run: [increment-retry, check-retry-limit]
+
+  # Increment retry counter
+  increment-retry:
+    type: memory
+    operation: set
+    key: retry_count
+    value_js: "memory.get('retry_count') + 1"
+
+  # Check if we should retry
+  check-retry-limit:
+    type: noop
+    depends_on: [increment-retry]
+    # Use goto_js to conditionally jump back to run-flaky-test
+    on_success:
+      goto_js: |
+        const retries = memory.get('retry_count');
+        log('Retry attempt:', retries);
+        return retries < 3 ? 'run-flaky-test' : null;
+
+  # Report final result
+  report-result:
+    type: log
+    depends_on: [run-flaky-test]
+    message: |
+      Test completed after {{ "retry_count" | memory_get }} retries
+
+output:
+  pr_comment:
+    format: markdown
+    group_by: check
+    collapse: false

package/dist/examples/memory-state-machine.yaml

@@ -0,0 +1,170 @@
+# Memory Example: Workflow State Machine
+#
+# This example demonstrates using memory to implement a state machine
+# for managing a multi-step workflow.
+
+version: "1.0"
+
+memory:
+  storage: file
+  file: ./workflow-state.json
+  format: json
+  namespace: deployment
+
+steps:
+  # Initialize workflow state
+  init-state:
+    type: memory
+    operation: set
+    key: state
+    value: pending
+    namespace: deployment
+
+  # Track start time
+  track-start:
+    type: memory
+    operation: set
+    key: start_time
+    value_js: "Date.now()"
+    depends_on: [init-state]
+
+  # Step 1: Build
+  build:
+    type: command
+    exec: npm run build
+    depends_on: [track-start]
+    on_success:
+      run: [set-state-built]
+    on_fail:
+      run: [set-state-build-failed]
+
+  set-state-built:
+    type: memory
+    operation: set
+    key: state
+    value: built
+
+  set-state-build-failed:
+    type: memory
+    operation: set
+    key: state
+    value: build_failed
+
+  # Step 2: Test (only if built)
+  test:
+    type: command
+    exec: npm test
+    depends_on: [set-state-built]
+    if: 'memory.get("state") === "built"'
+    on_success:
+      run: [set-state-tested]
+    on_fail:
+      run: [set-state-test-failed]
+
+  set-state-tested:
+    type: memory
+    operation: set
+    key: state
+    value: tested
+
+  set-state-test-failed:
+    type: memory
+    operation: set
+    key: state
+    value: test_failed
+
+  # Step 3: Deploy (only if tested)
+  deploy:
+    type: command
+    exec: npm run deploy
+    depends_on: [set-state-tested]
+    if: 'memory.get("state") === "tested"'
+    on_success:
+      run: [set-state-deployed]
+    on_fail:
+      run: [set-state-deploy-failed]
+
+  set-state-deployed:
+    type: memory
+    operation: set
+    key: state
+    value: deployed
+
+  set-state-deploy-failed:
+    type: memory
+    operation: set
+    key: state
+    value: deploy_failed
+
+  # Track end time
+  track-end:
+    type: memory
+    operation: set
+    key: end_time
+    value_js: "Date.now()"
+    depends_on: [deploy, set-state-build-failed, set-state-test-failed, set-state-deploy-failed]
+
+  # Calculate duration
+  calculate-duration:
+    type: memory
+    operation: set
+    key: duration_seconds
+    value_js: |
+      const start = memory.get('start_time');
+      const end = memory.get('end_time');
+      return Math.round((end - start) / 1000);
+    depends_on: [track-end]
+
+  # Report final state
+  report-state:
+    type: log
+    depends_on: [calculate-duration]
+    message: |
+      {% assign state = "state" | memory_get %}
+      {% assign duration = "duration_seconds" | memory_get %}
+
+      ## Workflow Status: {{ state | upcase }}
+
+      **Duration**: {{ duration }} seconds
+
+      {% case state %}
+      {% when "deployed" %}
+      ✅ **Deployment Successful!**
+
+      All steps completed:
+      1. ✅ Build
+      2. ✅ Test
+      3. ✅ Deploy
+
+      {% when "build_failed" %}
+      ❌ **Build Failed**
+
+      The build step failed. Please check the logs.
+
+      {% when "test_failed" %}
+      ❌ **Tests Failed**
+
+      Build succeeded, but tests failed.
+
+      {% when "deploy_failed" %}
+      ❌ **Deployment Failed**
+
+      Build and tests passed, but deployment failed.
+
+      {% else %}
+      ⏳ **Workflow In Progress**
+
+      Current state: {{ state }}
+      {% endcase %}
+
+  # Fail workflow if not deployed
+  check-deployment:
+    type: noop
+    depends_on: [report-state]
+    fail_if: 'memory.get("state") !== "deployed"'
+
+output:
+  pr_comment:
+    format: markdown
+    group_by: check
+    collapse: true