@probelabs/visor 0.1.106 → 0.1.111

package/dist/examples/if-conditions.yaml

@@ -0,0 +1,173 @@
+version: "1.0"
+
+# Example configuration showing how to use if conditions to control check execution
+# The if condition determines whether a check should run based on context
+
+steps:
+  # Run only on main branch
+  production-check:
+    type: ai
+    schema: code-review
+    prompt: "Check production readiness and deployment safety"
+    on: [pr_opened, pr_updated]
+    if: 'branch == "main" || baseBranch == "main"'
+    fail_if: "output.issues.some(i => i.severity === 'critical')"
+
+  # Run only when there are file changes
+  incremental-review:
+    type: ai
+    schema: code-review
+    prompt: "Review changed files for issues"
+    on: [pr_opened, pr_updated]
+    if: "filesCount > 0"
+    fail_if: "output.issues.some(i => i.severity === 'error')"
+
+  # Run only on feature branches
+  feature-validation:
+    type: ai
+    schema: code-review
+    prompt: "Validate feature implementation"
+    on: [pr_opened, pr_updated]
+    if: 'startsWith(branch, "feature/")'
+    fail_if: "output.issues.some(i => i.severity === 'critical')"
+
+  # Run only in CI environment
+  ci-only-check:
+    type: ai
+    schema: security
+    prompt: "Comprehensive security scan"
+    on: [pr_opened, pr_updated]
+    if: 'env.CI == "true"'
+    fail_if: "output.issues.length > 0"
+
+  # Run when specific files are changed
+  auth-security-check:
+    type: ai
+    schema: security
+    prompt: "Security review for authentication changes"
+    on: [pr_opened, pr_updated]
+    # Run when auth-related files are modified
+    if: 'contains(filesChanged, "auth") || contains(filesChanged, "login") || contains(filesChanged, "session")'
+    fail_if: "output.issues.length > 0"
+
+  # Complex condition - run on main or when many files changed
+  comprehensive-review:
+    type: ai
+    schema: code-review
+    prompt: "Comprehensive code review"
+    on: [pr_opened, pr_updated]
+    # Run on main branch OR when more than 10 files changed
+    if: 'branch == "main" || filesCount > 10'
+    fail_if: "output.issues.some(i => i.severity === 'critical')"
+
+  # Always run (default behavior)
+  standard-check:
+    type: ai
+    schema: code-review
+    prompt: "Standard code review"
+    on: [pr_opened, pr_updated]
+    if: "always()"  # Explicitly always run
+    fail_if: "output.issues.some(i => i.severity === 'critical')"
+
+  # Never run (can be enabled by removing/changing condition)
+  disabled-check:
+    type: ai
+    schema: code-review
+    prompt: "Currently disabled check"
+    on: [pr_opened, pr_updated]
+    if: "!always()"  # Never run
+    fail_if: "output.issues.some(i => i.severity === 'critical')"
+
+  # Dependency-based execution
+  security-check:
+    type: ai
+    schema: security
+    prompt: "Security vulnerability scan"
+    on: [pr_opened, pr_updated]
+    if: "always()"
+    fail_if: "output.issues.some(i => i.severity === 'critical')"
+
+  performance-check:
+    type: ai
+    schema: code-review
+    prompt: "Performance analysis"
+    on: [pr_opened, pr_updated]
+    if: "always()"
+    fail_if: "output.issues.filter(i => i.severity === 'error').length > 2"
+
+  # Run only if security check found issues
+  security-remediation:
+    type: ai
+    schema: code-review
+    prompt: "Suggest security fixes"
+    on: [pr_opened, pr_updated]
+    depends_on: [security-check]
+    # Only run if security check found issues (use length() function)
+    if: 'outputs["security-check"] && length(outputs["security-check"].issues) > 0'
+    fail_if: "output.issues.some(i => i.severity === 'critical')"
+
+  # Run only if all previous checks passed
+  final-validation:
+    type: ai
+    schema: code-review
+    prompt: "Final validation before merge"
+    on: [pr_opened, pr_updated]
+    depends_on: [security-check, performance-check]
+    # Only run if both dependencies passed (check for specific severities)
+    if: |
+      outputs["security-check"] &&
+      !hasIssue(outputs["security-check"].issues, "severity", "critical") &&
+      !hasIssue(outputs["security-check"].issues, "severity", "error") &&
+      outputs["performance-check"] &&
+      !hasIssue(outputs["performance-check"].issues, "severity", "critical") &&
+      !hasIssue(outputs["performance-check"].issues, "severity", "error")
+    fail_if: "output.issues.length > 0"
+
+  # Environment-specific checks
+  staging-check:
+    type: ai
+    schema: code-review
+    prompt: "Staging environment validation"
+    on: [pr_opened, pr_updated]
+    # Run only in staging environment
+    if: 'env.ENVIRONMENT == "staging"'
+    fail_if: "output.issues.some(i => i.severity === 'critical')"
+
+  # Time-based or conditional skip
+  weekend-check:
+    type: ai
+    schema: code-review
+    prompt: "Weekend maintenance check"
+    on: [pr_opened, pr_updated]
+    # Could be used with env vars set by CI to control execution
+    if: 'env.RUN_WEEKEND_CHECKS == "true"'
+    fail_if: "output.issues.some(i => i.severity === 'critical')"
+
+output:
+  pr_comment:
+    format: markdown
+    group_by: check
+    collapse: true
+
+# Available variables in if conditions:
+# - checkName: Name of the current check
+# - branch: Current branch name
+# - baseBranch: Target/base branch name
+# - filesChanged: Array of changed file paths
+# - filesCount: Number of changed files
+# - event: Event that triggered the check (e.g., "pr_opened", "manual")
+# - env: Environment variables
+# - outputs: Raw ReviewSummary objects from previous checks (for dependent checks)
+#   Example: outputs["check-name"].issues, outputs["check-name"].suggestions
+# - metadata: Additional metadata (hasChanges, branch, event, checkName)
+
+# Available functions (GitHub Actions-style):
+# - contains(haystack, needle): Check if string/array contains value
+# - startsWith(str, prefix): Check if string starts with prefix
+# - endsWith(str, suffix): Check if string ends with suffix
+# - always(): Always returns true
+# - length(array|string|object): Get length of array, string, or object keys
+# - hasIssue(issues, field, value): Check if any issue has field matching value
+# - countIssues(issues, field, value): Count issues with field matching value
+# - hasFileMatching(issues, pattern): Check if any issue file contains pattern
+# - Standard operators: ==, !=, >, <, >=, <=, &&, ||, !

package/dist/examples/jira-simple-example.yaml

@@ -0,0 +1,56 @@
+# Simple Jira MCP Example
+# Workflow: JQL Query → Pick One Issue → AI Analysis → Add Label
+
+version: "1.0"
+
+ai_provider: anthropic
+ai_model: claude-3-sonnet
+
+# Jira MCP Server
+ai_mcp_servers:
+  jira:
+    command: "npx"
+    args: ["-y", "@aashari/mcp-server-atlassian-jira"]
+    env:
+      JIRA_BASE_URL: "${JIRA_BASE_URL}"      # https://company.atlassian.net
+      JIRA_EMAIL: "${JIRA_EMAIL}"            # user@company.com
+      JIRA_API_TOKEN: "${JIRA_API_TOKEN}"    # your_api_token
+
+steps:
+  jira_analyze_and_label:
+    type: ai
+    prompt: |
+      Perform this exact Jira workflow:
+
+      1. **Query Issues**: Use JQL "project = DEV AND status = 'To Do' AND priority = High ORDER BY created DESC" to find high-priority todo items
+
+      2. **Pick First Issue**: Select the first (most recently created) issue from the results
+
+      3. **AI Analysis**: Analyze the selected issue for:
+         - Technical complexity (1-10 scale)
+         - Implementation risk (Low/Medium/High)
+         - Estimated effort in story points (1,2,3,5,8)
+         - Required skills/expertise
+
+      4. **Add Label**: Based on analysis, add ONE of these labels:
+         - "quick-win" (complexity ≤ 3, low risk)
+         - "standard-task" (complexity 4-6, low-medium risk)
+         - "complex-work" (complexity ≥ 7 or high risk)
+
+      5. **Report**: Output the issue key, analysis summary, and label added.
+
+      Use the Jira MCP tools to execute each step. Be concise but thorough.
+
+    on: ["manual"]
+    tags: ["jira", "simple"]
+
+# Environment setup required:
+# export JIRA_BASE_URL="https://your-company.atlassian.net"
+# export JIRA_EMAIL="your.email@company.com"
+# export JIRA_API_TOKEN="your_api_token"
+# export ANTHROPIC_API_KEY="your_anthropic_key"
+
+output:
+  markdown:
+    enabled: true
+    file: "./jira-analysis.md"

package/dist/examples/jira-single-issue-workflow.yaml

@@ -0,0 +1,166 @@
+# Simple Jira MCP workflow example
+# Demonstrates: JQL query → pick issue → AI analysis → add label
+
+version: "1.0"
+
+ai_provider: anthropic
+ai_model: claude-3-sonnet
+
+# Jira MCP server configuration
+ai_mcp_servers:
+  jira:
+    command: "npx"
+    args: ["-y", "@aashari/mcp-server-atlassian-jira"]
+    env:
+      JIRA_BASE_URL: "${JIRA_BASE_URL}"
+      JIRA_EMAIL: "${JIRA_EMAIL}"
+      JIRA_API_TOKEN: "${JIRA_API_TOKEN}"
+
+steps:
+  # Main workflow: JQL → Pick → Analyze → Label
+  jira_issue_analysis_workflow:
+    type: ai
+    prompt: |
+      Execute this Jira workflow using the available MCP tools:
+
+      ## Step 1: Query Issues with JQL
+      Search for issues using JQL: "project = DEV AND status = 'To Do' AND priority IN (High, Highest) ORDER BY created DESC"
+
+      Limit results to maximum 10 issues for analysis.
+
+      ## Step 2: Pick One Issue
+      From the search results:
+      1. Review each issue's summary and description
+      2. Select the MOST RECENTLY CREATED issue that appears to be:
+         - Well-defined (has clear description)
+         - Not blocked by dependencies
+         - Suitable for immediate analysis
+
+      ## Step 3: Deep Analysis
+      For the selected issue, perform comprehensive analysis:
+
+      ### Technical Analysis:
+      - **Complexity Score** (1-10): Based on technical requirements
+      - **Effort Estimation**: Story points (1, 2, 3, 5, 8, 13)
+      - **Risk Assessment**: Low/Medium/High
+      - **Component Impact**: Which system components affected
+
+      ### Business Analysis:
+      - **Business Value**: Critical/High/Medium/Low
+      - **User Impact**: How many users affected
+      - **Urgency Level**: Immediate/Soon/Later
+      - **Dependencies**: What blocks or depends on this
+
+      ### Implementation Analysis:
+      - **Approach Recommendation**: Suggested implementation strategy
+      - **Testing Requirements**: What tests are needed
+      - **Rollback Plan**: How to revert if needed
+      - **Documentation Needs**: What docs need updating
+
+      ## Step 4: Add Analysis Labels
+      Based on your analysis, add appropriate labels to the issue:
+
+      **Always add:**
+      - "ai-analyzed"
+      - Current date label: "analyzed-YYYY-MM-DD"
+
+      **Complexity labels (pick one):**
+      - "simple-fix" (score 1-3)
+      - "moderate-complexity" (score 4-6)
+      - "complex-implementation" (score 7-10)
+
+      **Priority labels (pick one):**
+      - "urgent-fix" (critical business impact)
+      - "high-priority" (important but not urgent)
+      - "normal-priority" (standard development)
+
+      **Risk labels (pick one):**
+      - "low-risk" (safe to implement)
+      - "medium-risk" (needs careful testing)
+      - "high-risk" (potential system impact)
+
+      **Component labels (pick relevant ones):**
+      - "frontend", "backend", "database", "api", "integration"
+
+      ## Step 5: Add Analysis Comment
+      Add a comment to the issue with:
+      ```
+      🤖 AI Analysis Summary
+
+      **Complexity:** [score]/10 - [reasoning]
+      **Effort:** [story points] points
+      **Risk:** [level] - [explanation]
+      **Priority:** [level] - [justification]
+
+      **Recommended Approach:**
+      [implementation strategy]
+
+      **Key Considerations:**
+      - [consideration 1]
+      - [consideration 2]
+      - [consideration 3]
+
+      **Testing Focus:**
+      [testing recommendations]
+
+      ---
+      *Analysis performed by Visor AI on [timestamp]*
+      ```
+
+      ## Step 6: Report Results
+      Provide a summary of:
+      - JQL query used and results count
+      - Selected issue key and title
+      - Analysis summary
+      - Labels added
+      - Comment added
+      - Any errors or warnings
+
+      Use the Jira MCP tools for all interactions. Be specific about which tools you're calling and with what parameters.
+
+    on: ["manual"]
+    tags: ["jira", "workflow", "analysis"]
+
+  # Alternative: Analyze specific issue by key (simpler version)
+  analyze_jira_issue_by_key:
+    type: ai
+    prompt: |
+      Analyze a specific Jira issue using MCP tools:
+
+      ## Instructions:
+      If an issue key is provided in the context (e.g., "DEV-123"), use it.
+      Otherwise, use this default JQL to find an issue: "project = DEV AND status = 'To Do' ORDER BY priority DESC, created DESC"
+
+      ## Analysis Process:
+      1. **Get Issue Details**: Retrieve full issue information
+      2. **Evaluate Complexity**: Rate 1-10 based on description/requirements
+      3. **Assess Risk**: Consider implementation challenges
+      4. **Estimate Effort**: Suggest story points
+      5. **Add Labels**:
+         - "ai-quick-analysis"
+         - Complexity: "simple" or "complex"
+         - Risk: "safe" or "risky"
+      6. **Add Comment**: Brief analysis summary
+
+      ## Expected Output:
+      - Issue analyzed: [KEY] - [TITLE]
+      - Complexity: [rating]/10
+      - Risk: [level]
+      - Effort: [points] story points
+      - Labels added: [list]
+      - Analysis reasoning: [brief explanation]
+
+    on: ["manual"]
+    tags: ["jira", "quick-analysis"]
+
+# Required environment variables:
+# JIRA_BASE_URL=https://your-company.atlassian.net
+# JIRA_EMAIL=your.email@company.com
+# JIRA_API_TOKEN=your_jira_api_token
+# ANTHROPIC_API_KEY=your_anthropic_key
+
+output:
+  json:
+    enabled: true
+  markdown:
+    enabled: true

package/dist/examples/jira-workflow-mcp.yaml

@@ -0,0 +1,182 @@
+# Visor configuration for Jira workflow automation using MCP
+# This example demonstrates:
+# 1. Listing Jira issues using JQL
+# 2. AI analysis of selected issues
+# 3. Adding labels to issues based on analysis
+
+version: "1.0"
+
+# Global AI configuration
+ai_provider: anthropic
+ai_model: claude-3-sonnet
+
+# Global MCP servers - Jira integration
+ai_mcp_servers:
+  jira:
+    command: "npx"
+    args: ["-y", "@aashari/mcp-server-atlassian-jira"]
+    env:
+      JIRA_BASE_URL: "${JIRA_BASE_URL}"        # https://your-company.atlassian.net
+      JIRA_EMAIL: "${JIRA_EMAIL}"              # your-email@company.com
+      JIRA_API_TOKEN: "${JIRA_API_TOKEN}"      # Your Jira API token
+
+steps:
+  # Step 1: Query and analyze high-priority bugs
+  analyze_priority_bugs:
+    type: ai
+    prompt: |
+      Use the Jira MCP tools to perform the following workflow:
+
+      1. Search for high-priority bugs using JQL: "project = DEV AND issuetype = Bug AND priority = High AND status != Closed"
+
+      2. For each issue found:
+         - Get detailed information about the issue
+         - Analyze the issue description, summary, and comments
+         - Evaluate the complexity and impact based on:
+           * Technical complexity indicators
+           * Business impact keywords
+           * Time sensitivity markers
+           * Dependencies mentioned
+
+      3. Classify each issue into categories:
+         - CRITICAL: Needs immediate attention (production impact, security, data loss)
+         - COMPLEX: Requires senior developer (architecture, performance, integration)
+         - ROUTINE: Standard bug fix (UI, validation, minor functionality)
+         - BLOCKED: Waiting for dependencies or more information
+
+      4. For each analyzed issue, add appropriate labels:
+         - "ai-analyzed" (always add this)
+         - "critical-bug" for CRITICAL issues
+         - "complex-implementation" for COMPLEX issues
+         - "quick-fix" for ROUTINE issues
+         - "needs-clarification" for BLOCKED issues
+
+      5. Provide a summary report of:
+         - Total issues analyzed
+         - Distribution by category
+         - Top 3 most critical issues with reasoning
+         - Recommended next actions
+
+      Use the available Jira MCP tools to search, retrieve, and update issues.
+    on: ["manual"]  # Trigger manually or via cron
+    tags: ["jira", "analysis", "priority"]
+
+  # Step 2: Analyze specific issue by key
+  analyze_specific_issue:
+    type: ai
+    prompt: |
+      Use the Jira MCP tools to analyze a specific issue:
+
+      1. Get the issue details for the provided issue key
+      2. Perform deep analysis including:
+         - Root cause investigation based on description
+         - Impact assessment on system components
+         - Effort estimation (story points recommendation)
+         - Risk assessment for implementation
+         - Suggested implementation approach
+
+      3. Based on analysis, add appropriate labels:
+         - Effort: "1-point", "3-points", "5-points", "8-points"
+         - Risk: "low-risk", "medium-risk", "high-risk"
+         - Component: "frontend", "backend", "database", "integration"
+         - Priority: "expedite", "normal", "defer"
+
+      4. If the issue is critical or complex, also:
+         - Add comment with AI analysis summary
+         - Set appropriate priority if not already set
+         - Suggest assignee if possible
+
+      Provide detailed reasoning for all assessments and actions taken.
+    on: ["manual"]
+    tags: ["jira", "deep-analysis", "individual"]
+
+  # Step 3: Sprint planning assistant
+  sprint_planning_analysis:
+    type: ai
+    prompt: |
+      Use Jira MCP tools to assist with sprint planning:
+
+      1. Query issues for upcoming sprint using JQL: "project = DEV AND sprint is EMPTY AND status = 'To Do' ORDER BY priority DESC, created ASC"
+
+      2. For each issue, analyze:
+         - Story point estimation based on complexity
+         - Dependencies between issues
+         - Team capacity alignment
+         - Risk factors
+
+      3. Recommend sprint composition:
+         - Categorize issues by complexity (Simple/Medium/Complex)
+         - Identify potential blockers
+         - Suggest issue prioritization
+         - Flag issues needing clarification
+
+      4. Add planning labels:
+         - "sprint-ready" for well-defined issues
+         - "needs-refinement" for unclear requirements
+         - "dependency-risk" for issues with external dependencies
+         - "good-first-issue" for junior developer tasks
+
+      5. Generate sprint planning report with:
+         - Recommended story point distribution
+         - Risk assessment
+         - Dependency mapping
+         - Team allocation suggestions
+
+      Use Jira MCP tools to query, analyze, and update issues accordingly.
+    schedule: "0 9 * * MON"  # Run every Monday at 9 AM for weekly planning
+    on: ["schedule"]
+    tags: ["jira", "planning", "automation"]
+
+  # Step 4: Issue health monitoring
+  issue_health_monitor:
+    type: ai
+    prompt: |
+      Monitor issue health using Jira MCP tools:
+
+      1. Query stale issues: "project = DEV AND status = 'In Progress' AND updated < -7d"
+      2. Query blocked issues: "project = DEV AND status = Blocked"
+      3. Query overdue issues: "project = DEV AND duedate < now() AND status != Done"
+
+      For each category, analyze and take action:
+
+      STALE ISSUES:
+      - Add "stale-issue" label
+      - Add comment requesting status update
+      - Notify stakeholders if high priority
+
+      BLOCKED ISSUES:
+      - Analyze blocking reasons from comments
+      - Add "needs-unblocking" label if actionable
+      - Escalate if blocked > 5 days
+
+      OVERDUE ISSUES:
+      - Add "overdue" label
+      - Assess impact and urgency
+      - Recommend timeline adjustment or priority change
+
+      Generate health report with:
+      - Issue distribution by health status
+      - Trending analysis (improving/degrading)
+      - Action items for team leads
+      - Automated remediation suggestions
+
+      Use Jira MCP tools for all queries and updates.
+    schedule: "0 10 * * MON,WED,FRI"  # Run 3 times per week
+    on: ["schedule"]
+    tags: ["jira", "monitoring", "health"]
+
+# Environment variables needed (set these in your environment):
+# JIRA_BASE_URL=https://your-company.atlassian.net
+# JIRA_EMAIL=your-email@company.com
+# JIRA_API_TOKEN=your-jira-api-token
+# ANTHROPIC_API_KEY=your-anthropic-api-key
+
+output:
+  pr_comment:
+    enabled: false  # These are Jira workflows, not PR-based
+  json:
+    enabled: true
+    file: "./jira-analysis-results.json"
+  markdown:
+    enabled: true
+    file: "./jira-analysis-report.md"

package/dist/examples/mcp/analyzer.py

@@ -0,0 +1,119 @@
+#!/usr/bin/env python3
+"""
+Example MCP Server for Code Analysis
+This demonstrates how to create a custom MCP server for Visor
+"""
+
+import json
+import sys
+import os
+from typing import Dict, List, Any
+
+class CodeAnalyzer:
+    """Custom code analyzer MCP server"""
+
+    def __init__(self):
+        self.analysis_level = os.environ.get('ANALYSIS_LEVEL', 'basic')
+
+    def analyze_complexity(self, file_path: str) -> Dict[str, Any]:
+        """Analyze code complexity"""
+        # This is a simplified example
+        # In reality, you would parse the code and calculate metrics
+        return {
+            "file": file_path,
+            "complexity": {
+                "cyclomatic": 5,
+                "cognitive": 8,
+                "lines_of_code": 150,
+                "functions": 10
+            },
+            "level": self.analysis_level
+        }
+
+    def find_patterns(self, file_path: str) -> List[Dict[str, Any]]:
+        """Find code patterns and anti-patterns"""
+        return [
+            {
+                "pattern": "singleton",
+                "location": f"{file_path}:45",
+                "type": "design_pattern"
+            },
+            {
+                "pattern": "god_object",
+                "location": f"{file_path}:120",
+                "type": "anti_pattern",
+                "severity": "warning"
+            }
+        ]
+
+    def suggest_refactoring(self, file_path: str) -> List[str]:
+        """Suggest refactoring opportunities"""
+        return [
+            "Consider extracting method at line 45-60",
+            "Duplicate code detected at lines 120 and 180",
+            "Complex conditional at line 95 could be simplified"
+        ]
+
+def handle_request(request: Dict[str, Any]) -> Dict[str, Any]:
+    """Handle MCP protocol requests"""
+    analyzer = CodeAnalyzer()
+
+    method = request.get('method')
+    params = request.get('params', {})
+
+    if method == 'analyze_complexity':
+        result = analyzer.analyze_complexity(params.get('file'))
+    elif method == 'find_patterns':
+        result = analyzer.find_patterns(params.get('file'))
+    elif method == 'suggest_refactoring':
+        result = analyzer.suggest_refactoring(params.get('file'))
+    else:
+        result = {"error": f"Unknown method: {method}"}
+
+    return {
+        "jsonrpc": "2.0",
+        "id": request.get('id'),
+        "result": result
+    }
+
+def main():
+    """Main entry point for MCP server"""
+    # Read from stdin (MCP protocol)
+    while True:
+        try:
+            line = sys.stdin.readline()
+            if not line:
+                break
+
+            request = json.loads(line)
+            response = handle_request(request)
+
+            # Write response to stdout
+            sys.stdout.write(json.dumps(response) + '\n')
+            sys.stdout.flush()
+
+        except json.JSONDecodeError as e:
+            error_response = {
+                "jsonrpc": "2.0",
+                "id": None,
+                "error": {
+                    "code": -32700,
+                    "message": f"Parse error: {str(e)}"
+                }
+            }
+            sys.stdout.write(json.dumps(error_response) + '\n')
+            sys.stdout.flush()
+        except Exception as e:
+            error_response = {
+                "jsonrpc": "2.0",
+                "id": None,
+                "error": {
+                    "code": -32603,
+                    "message": f"Internal error: {str(e)}"
+                }
+            }
+            sys.stdout.write(json.dumps(error_response) + '\n')
+            sys.stdout.flush()
+
+if __name__ == "__main__":
+    main()