@boshu2/vibe-check 2.3.0 → 2.4.0

package/drivers/go.sh

@@ -0,0 +1,131 @@
+#!/bin/bash
+# drivers/go.sh
+# Wraps gocyclo to produce standard complexity JSON
+#
+# Usage: ./drivers/go.sh [directory]
+#        directory: Path to Go code to analyze (default: current directory)
+#
+# Output: JSON conforming to ComplexityReport schema
+# Exit codes: 0 = success, 1 = error (gocyclo not installed or other failure)
+
+set -euo pipefail
+
+TARGET_DIR="${1:-.}"
+
+# Check gocyclo is installed
+if ! command -v gocyclo &> /dev/null; then
+    echo '{"error": "gocyclo not installed. Run: go install github.com/fzipp/gocyclo/cmd/gocyclo@latest"}' >&2
+    exit 1
+fi
+
+# Check if target directory exists
+if [ ! -d "$TARGET_DIR" ]; then
+    echo "{\"error\": \"Directory not found: $TARGET_DIR\"}" >&2
+    exit 1
+fi
+
+# Check if there are any Go files
+if ! find "$TARGET_DIR" -name "*.go" ! -path "*/vendor/*" -print -quit 2>/dev/null | grep -q .; then
+    # No Go files found, output empty result
+    echo '{"tool":"gocyclo","language":"go","generatedAt":"'$(date -u +"%Y-%m-%dT%H:%M:%SZ")'","files":{},"summary":{"totalFiles":0,"totalFunctions":0,"avgComplexity":0,"gradeDistribution":{"A":0,"B":0,"C":0,"D":0,"E":0,"F":0}}}'
+    exit 0
+fi
+
+# Run gocyclo and transform output
+# gocyclo outputs lines like:
+#   8 main complex /tmp/go-test/main.go:16:1
+#   <complexity> <package> <function> <file:row:column>
+
+gocyclo "$TARGET_DIR" 2>/dev/null | awk -v target_dir="$TARGET_DIR" '
+BEGIN {
+    # Initialize
+    file_count = 0
+    func_count = 0
+    total_complexity = 0
+    grade_a = 0; grade_b = 0; grade_c = 0; grade_d = 0; grade_e = 0; grade_f = 0
+}
+
+function complexity_to_grade(c) {
+    if (c <= 5) return "A"
+    else if (c <= 10) return "B"
+    else if (c <= 20) return "C"
+    else if (c <= 30) return "D"
+    else if (c <= 40) return "E"
+    else return "F"
+}
+
+function increment_grade(g) {
+    if (g == "A") grade_a++
+    else if (g == "B") grade_b++
+    else if (g == "C") grade_c++
+    else if (g == "D") grade_d++
+    else if (g == "E") grade_e++
+    else grade_f++
+}
+
+{
+    # Parse: complexity package function file:line:col
+    complexity = $1
+    pkg = $2
+    func_name = $3
+    file_line = $4
+
+    # Split file:line:col
+    split(file_line, parts, ":")
+    file = parts[1]
+    line = parts[2]
+
+    # Track functions per file
+    if (!(file in files)) {
+        files[file] = 1
+        file_count++
+        file_functions[file] = ""
+        file_complexities[file] = ""
+        file_total[file] = 0
+        file_max[file] = 0
+        file_func_count[file] = 0
+    }
+
+    func_count++
+    total_complexity += complexity
+
+    grade = complexity_to_grade(complexity)
+
+    # Append function data (JSON format)
+    sep = (file_functions[file] == "") ? "" : ","
+    file_functions[file] = file_functions[file] sep sprintf("{\"name\":\"%s\",\"complexity\":%d,\"grade\":\"%s\",\"line\":%d,\"endLine\":null}", func_name, complexity, grade, line)
+
+    # Track file stats
+    file_total[file] += complexity
+    file_func_count[file]++
+    if (complexity > file_max[file]) {
+        file_max[file] = complexity
+    }
+}
+
+END {
+    # Output JSON
+    printf "{\"tool\":\"gocyclo\",\"language\":\"go\",\"generatedAt\":\""
+    # Get current timestamp
+    cmd = "date -u +\"%Y-%m-%dT%H:%M:%SZ\""
+    cmd | getline timestamp
+    close(cmd)
+    printf "%s\",\"files\":{", timestamp
+
+    first_file = 1
+    for (file in files) {
+        if (!first_file) printf ","
+        first_file = 0
+
+        avg = (file_func_count[file] > 0) ? file_total[file] / file_func_count[file] : 0
+        file_grade = complexity_to_grade(avg)
+        increment_grade(file_grade)
+
+        printf "\"%s\":{\"functions\":[%s],\"avgComplexity\":%.2f,\"maxComplexity\":%d,\"grade\":\"%s\"}", file, file_functions[file], avg, file_max[file], file_grade
+    }
+
+    avg_complexity = (func_count > 0) ? total_complexity / func_count : 0
+
+    printf "},\"summary\":{\"totalFiles\":%d,\"totalFunctions\":%d,\"avgComplexity\":%.2f,\"gradeDistribution\":{\"A\":%d,\"B\":%d,\"C\":%d,\"D\":%d,\"E\":%d,\"F\":%d}}}", file_count, func_count, avg_complexity, grade_a, grade_b, grade_c, grade_d, grade_e, grade_f
+}
+'

package/drivers/java.sh

@@ -0,0 +1,137 @@
+#!/bin/bash
+# drivers/java.sh
+# Wraps PMD to produce standard complexity JSON
+#
+# Usage: ./drivers/java.sh [directory]
+#        directory: Path to Java code to analyze (default: current directory)
+#
+# Output: JSON conforming to ComplexityReport schema
+# Exit codes: 0 = success, 1 = error (pmd not installed or other failure)
+
+set -euo pipefail
+
+TARGET_DIR="${1:-.}"
+
+# Check pmd is installed
+if ! command -v pmd &> /dev/null; then
+    echo '{"error": "pmd not installed. Download from: https://pmd.github.io/"}' >&2
+    exit 1
+fi
+
+# Check if target directory exists
+if [ ! -d "$TARGET_DIR" ]; then
+    echo "{\"error\": \"Directory not found: $TARGET_DIR\"}" >&2
+    exit 1
+fi
+
+# Check if there are any Java files
+if ! find "$TARGET_DIR" -name "*.java" ! -path "*/target/*" ! -path "*/build/*" -print -quit 2>/dev/null | grep -q .; then
+    # No Java files found, output empty result
+    echo '{"tool":"pmd","language":"java","generatedAt":"'$(date -u +"%Y-%m-%dT%H:%M:%SZ")'","files":{},"summary":{"totalFiles":0,"totalFunctions":0,"avgComplexity":0,"gradeDistribution":{"A":0,"B":0,"C":0,"D":0,"E":0,"F":0}}}'
+    exit 0
+fi
+
+# Run PMD and transform output
+# PMD outputs JSON with violations grouped by file
+# We filter for CyclomaticComplexity rule violations
+# Using --no-cache to avoid caching issues
+# --ignore-violations to ensure exit 0 even with violations found
+
+pmd check -d "$TARGET_DIR" \
+  -R category/java/design.xml/CyclomaticComplexity \
+  -f json \
+  --no-cache \
+  --ignore-violations-on-exit 2>/dev/null | jq -c '
+# Helper function for complexity to grade conversion
+def complexity_to_grade:
+  if . <= 5 then "A"
+  elif . <= 10 then "B"
+  elif . <= 20 then "C"
+  elif . <= 30 then "D"
+  elif . <= 40 then "E"
+  else "F"
+  end;
+
+# Process PMD violations format
+# PMD JSON format has .files array with violations
+(.files // []) |
+map(
+  select(.violations | length > 0) |
+  {
+    path: .filename,
+    violations: [
+      .violations[] |
+      # PMD description format: "The {class|method} {name} has a {Cyclomatic|Standard} Complexity of {X}."
+      # or "The {class|method} '{name}' has a {Cyclomatic|Standard} cyclomatic complexity of {X}."
+      {
+        description: .description,
+        method: (.description | capture("method .(?<name>[^']+).") | .name),
+        beginLine: .beginLine,
+        endLine: .endLine,
+        # Extract complexity number from description
+        complexity: (
+          .description |
+          capture("complexity of (?<num>[0-9]+)") |
+          .num | tonumber
+        )
+      }
+    ]
+  } |
+  select(.violations | length > 0)
+) |
+
+# Group by file and calculate metrics
+map({
+  key: .path,
+  value: {
+    functions: (
+      .violations | map({
+        name: .method,
+        complexity: .complexity,
+        grade: (.complexity | complexity_to_grade),
+        line: .beginLine,
+        endLine: .endLine
+      })
+    ),
+    avgComplexity: (
+      if (.violations | length) > 0 then
+        ((.violations | map(.complexity) | add) / (.violations | length))
+      else 0 end
+    ),
+    maxComplexity: (
+      if (.violations | length) > 0 then
+        (.violations | map(.complexity) | max)
+      else 0 end
+    ),
+    grade: (
+      if (.violations | length) > 0 then
+        (((.violations | map(.complexity) | add) / (.violations | length)) | complexity_to_grade)
+      else "A" end
+    )
+  }
+}) |
+from_entries as $files |
+
+# Build final output
+{
+  tool: "pmd",
+  language: "java",
+  generatedAt: (now | todate),
+  files: $files,
+  summary: {
+    totalFiles: ($files | to_entries | length),
+    totalFunctions: ([$files | to_entries[].value.functions | length] | add // 0),
+    avgComplexity: (
+      [$files | to_entries[].value.avgComplexity] |
+      if length > 0 then (add / length) else 0 end
+    ),
+    gradeDistribution: (
+      [$files | to_entries[].value.grade] |
+      reduce .[] as $grade (
+        {A: 0, B: 0, C: 0, D: 0, E: 0, F: 0};
+        .[$grade] += 1
+      )
+    )
+  }
+}
+'

package/drivers/javascript.sh

@@ -0,0 +1,134 @@
+#!/bin/bash
+# drivers/javascript.sh
+# Wraps cyclomatic-complexity to produce standard complexity JSON
+#
+# Usage: ./drivers/javascript.sh [directory]
+#        directory: Path to JavaScript/TypeScript code to analyze (default: current directory)
+#
+# Output: JSON conforming to ComplexityReport schema
+# Exit codes: 0 = success, 1 = error (npx not available or other failure)
+
+set -euo pipefail
+
+TARGET_DIR="${1:-.}"
+
+# Check if npx is available
+if ! command -v npx &> /dev/null; then
+    echo '{"error": "npx not found. Install Node.js and npm."}' >&2
+    exit 1
+fi
+
+# Check if target directory exists
+if [ ! -d "$TARGET_DIR" ]; then
+    echo "{\"error\": \"Directory not found: $TARGET_DIR\"}" >&2
+    exit 1
+fi
+
+# Find all JS/TS files (excluding common build/dep directories)
+FILES=$(find "$TARGET_DIR" -type f \( -name "*.js" -o -name "*.ts" -o -name "*.jsx" -o -name "*.tsx" \) \
+  ! -path "*/node_modules/*" \
+  ! -path "*/dist/*" \
+  ! -path "*/build/*" \
+  ! -path "*/.next/*" \
+  ! -path "*/coverage/*" 2>/dev/null)
+
+# If no files found, output empty result
+if [ -z "$FILES" ]; then
+  echo '{"tool":"cyclomatic-complexity","language":"javascript","generatedAt":"'$(date -u +"%Y-%m-%dT%H:%M:%SZ")'","files":{},"summary":{"totalFiles":0,"totalFunctions":0,"avgComplexity":0,"gradeDistribution":{"A":0,"B":0,"C":0,"D":0,"E":0,"F":0}}}'
+  exit 0
+fi
+
+# Build glob pattern for cyclomatic-complexity
+# It expects quoted glob patterns like 'src/**/*.ts'
+PATTERN="${TARGET_DIR}/**/*.{js,ts,jsx,tsx}"
+
+# Run cyclomatic-complexity and transform output
+# cyclomatic-complexity outputs JSON like:
+# [
+#   {
+#     "file": "path/to/file.js",
+#     "functionComplexities": [
+#       {"name": "func", "complexity": 5, "line": 10}
+#     ],
+#     "complexitySum": 5,
+#     "complexityLevel": "ok"
+#   }
+# ]
+
+npx --yes cyclomatic-complexity "$PATTERN" --json 2>/dev/null | jq -c '
+# Filter out empty files and global scope functions
+map(
+  select(.functionComplexities | length > 0) |
+  . + {functionComplexities: [.functionComplexities[] | select(.name != "global")]}
+) |
+map(select(.functionComplexities | length > 0)) |
+
+# Transform to standard schema
+(
+  map({
+    key: .file,
+    value: {
+      functions: (
+        .functionComplexities | map({
+          name: .name,
+          complexity: .complexity,
+          grade: (
+            if .complexity <= 5 then "A"
+            elif .complexity <= 10 then "B"
+            elif .complexity <= 20 then "C"
+            elif .complexity <= 30 then "D"
+            elif .complexity <= 40 then "E"
+            else "F"
+            end
+          ),
+          line: .line,
+          endLine: null
+        })
+      ),
+      avgComplexity: (
+        if (.functionComplexities | length) > 0 then
+          ((.functionComplexities | map(.complexity) | add) / (.functionComplexities | length))
+        else 0 end
+      ),
+      maxComplexity: (
+        if (.functionComplexities | length) > 0 then
+          (.functionComplexities | map(.complexity) | max)
+        else 0 end
+      ),
+      grade: (
+        if (.functionComplexities | length) > 0 then
+          ((.functionComplexities | map(.complexity) | add) / (.functionComplexities | length)) as $avg |
+          if $avg <= 5 then "A"
+          elif $avg <= 10 then "B"
+          elif $avg <= 20 then "C"
+          elif $avg <= 30 then "D"
+          elif $avg <= 40 then "E"
+          else "F"
+          end
+        else "A" end
+      )
+    }
+  }) | from_entries
+) as $files |
+{
+  tool: "cyclomatic-complexity",
+  language: "javascript",
+  generatedAt: (now | todate),
+  files: $files,
+  summary: {
+    totalFiles: ($files | to_entries | length),
+    totalFunctions: ([$files | to_entries[].value.functions | length] | add // 0),
+    avgComplexity: (
+      [$files | to_entries[].value.avgComplexity] |
+      if length > 0 then (add / length) else 0 end
+    ),
+    gradeDistribution: (
+      [$files | to_entries[].value.grade] |
+      reduce .[] as $grade (
+        {A: 0, B: 0, C: 0, D: 0, E: 0, F: 0};
+        .[$grade] += 1
+      )
+    )
+  }
+}
+'

package/drivers/php.sh

@@ -0,0 +1,132 @@
+#!/bin/bash
+# drivers/php.sh
+# Wraps PHPMD to produce standard complexity JSON
+#
+# Usage: ./drivers/php.sh [directory]
+#        directory: Path to PHP code to analyze (default: current directory)
+#
+# Output: JSON conforming to ComplexityReport schema
+# Exit codes: 0 = success, 1 = error (phpmd not installed or other failure)
+
+set -euo pipefail
+
+TARGET_DIR="${1:-.}"
+
+# Check phpmd is installed
+if ! command -v phpmd &> /dev/null; then
+    echo '{"error": "phpmd not installed. Run: composer global require phpmd/phpmd"}' >&2
+    exit 1
+fi
+
+# Check if target directory exists
+if [ ! -d "$TARGET_DIR" ]; then
+    echo "{\"error\": \"Directory not found: $TARGET_DIR\"}" >&2
+    exit 1
+fi
+
+# Check if there are any PHP files
+if ! find "$TARGET_DIR" -name "*.php" ! -path "*/vendor/*" -print -quit 2>/dev/null | grep -q .; then
+    # No PHP files found, output empty result
+    echo '{"tool":"phpmd","language":"php","generatedAt":"'$(date -u +"%Y-%m-%dT%H:%M:%SZ")'","files":{},"summary":{"totalFiles":0,"totalFunctions":0,"avgComplexity":0,"gradeDistribution":{"A":0,"B":0,"C":0,"D":0,"E":0,"F":0}}}'
+    exit 0
+fi
+
+# Run PHPMD and transform output
+# PHPMD outputs JSON violations, we need to extract cyclomatic complexity violations
+# and transform them to our schema
+# Using --ignore-violations-on-exit to ensure exit 0 even with violations
+
+phpmd "$TARGET_DIR" json codesize --exclude vendor --ignore-violations-on-exit 2>/dev/null | jq -c '
+# Helper function for complexity to grade conversion
+def complexity_to_grade:
+  if . <= 5 then "A"
+  elif . <= 10 then "B"
+  elif . <= 20 then "C"
+  elif . <= 30 then "D"
+  elif . <= 40 then "E"
+  else "F"
+  end;
+
+# Process PHPMD violations format
+# Extract only CyclomaticComplexity violations
+.files |
+map(
+  select(.violations | length > 0) |
+  {
+    path: .file,
+    violations: [
+      .violations[] |
+      select(.rule == "CyclomaticComplexity") |
+      {
+        # Parse complexity from description like "The method foo() has a Cyclomatic Complexity of 12."
+        description: .description,
+        method: .method,
+        beginLine: .beginLine,
+        endLine: .endLine,
+        # Extract complexity number from description using regex
+        complexity: (
+          .description |
+          capture("Cyclomatic Complexity of (?<num>[0-9]+)") |
+          .num | tonumber
+        )
+      }
+    ]
+  } |
+  select(.violations | length > 0)
+) |
+
+# Group by file and calculate metrics
+map({
+  key: .path,
+  value: {
+    functions: (
+      .violations | map({
+        name: .method,
+        complexity: .complexity,
+        grade: (.complexity | complexity_to_grade),
+        line: .beginLine,
+        endLine: .endLine
+      })
+    ),
+    avgComplexity: (
+      if (.violations | length) > 0 then
+        ((.violations | map(.complexity) | add) / (.violations | length))
+      else 0 end
+    ),
+    maxComplexity: (
+      if (.violations | length) > 0 then
+        (.violations | map(.complexity) | max)
+      else 0 end
+    ),
+    grade: (
+      if (.violations | length) > 0 then
+        (((.violations | map(.complexity) | add) / (.violations | length)) | complexity_to_grade)
+      else "A" end
+    )
+  }
+}) |
+from_entries as $files |
+
+# Build final output
+{
+  tool: "phpmd",
+  language: "php",
+  generatedAt: (now | todate),
+  files: $files,
+  summary: {
+    totalFiles: ($files | to_entries | length),
+    totalFunctions: ([$files | to_entries[].value.functions | length] | add // 0),
+    avgComplexity: (
+      [$files | to_entries[].value.avgComplexity] |
+      if length > 0 then (add / length) else 0 end
+    ),
+    gradeDistribution: (
+      [$files | to_entries[].value.grade] |
+      reduce .[] as $grade (
+        {A: 0, B: 0, C: 0, D: 0, E: 0, F: 0};
+        .[$grade] += 1
+      )
+    )
+  }
+}
+'

package/drivers/python.sh

@@ -0,0 +1,90 @@
+#!/bin/bash
+# drivers/python.sh
+# Wraps radon to produce standard complexity JSON
+#
+# Usage: ./drivers/python.sh [directory]
+#        directory: Path to Python code to analyze (default: current directory)
+#
+# Output: JSON conforming to ComplexityReport schema
+# Exit codes: 0 = success, 1 = error (radon not installed or other failure)
+
+set -euo pipefail
+
+TARGET_DIR="${1:-.}"
+
+# Check radon is installed
+if ! command -v radon &> /dev/null; then
+    echo '{"error": "radon not installed. Run: pip install radon"}' >&2
+    exit 1
+fi
+
+# Check if target directory exists
+if [ ! -d "$TARGET_DIR" ]; then
+    echo "{\"error\": \"Directory not found: $TARGET_DIR\"}" >&2
+    exit 1
+fi
+
+# Run radon and transform output
+# radon cc outputs JSON like:
+# {
+#   "file.py": [
+#     {"name": "func", "complexity": 5, "rank": "A", "lineno": 10, ...}
+#   ]
+# }
+radon cc "$TARGET_DIR" -j --total-average 2>/dev/null | jq -c '
+(to_entries | map({
+  key: .key,
+  value: {
+    functions: (.value | map({
+      name: .name,
+      complexity: .complexity,
+      grade: .rank,
+      line: .lineno,
+      endLine: .endline
+    })),
+    avgComplexity: (
+      if (.value | length) > 0 then
+        ((.value | map(.complexity) | add) / (.value | length))
+      else 0 end
+    ),
+    maxComplexity: (
+      if (.value | length) > 0 then
+        (.value | map(.complexity) | max)
+      else 0 end
+    ),
+    grade: (
+      if (.value | length) > 0 then
+        ((.value | map(.complexity) | add) / (.value | length)) as $avg |
+        if $avg <= 5 then "A"
+        elif $avg <= 10 then "B"
+        elif $avg <= 20 then "C"
+        elif $avg <= 30 then "D"
+        elif $avg <= 40 then "E"
+        else "F"
+        end
+      else "A" end
+    )
+  }
+}) | from_entries) as $files |
+{
+  tool: "radon",
+  language: "python",
+  generatedAt: (now | todate),
+  files: $files,
+  summary: {
+    totalFiles: ($files | to_entries | length),
+    totalFunctions: ([$files | to_entries[].value.functions | length] | add // 0),
+    avgComplexity: (
+      [$files | to_entries[].value.avgComplexity] |
+      if length > 0 then (add / length) else 0 end
+    ),
+    gradeDistribution: (
+      [$files | to_entries[].value.grade] |
+      reduce .[] as $grade (
+        {A: 0, B: 0, C: 0, D: 0, E: 0, F: 0};
+        .[$grade] += 1
+      )
+    )
+  }
+}
+'