@boshu2/vibe-check 2.2.1 → 2.4.0

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
+      )
+    )
+  }
+}
+'

package/drivers/rust.sh

@@ -0,0 +1,132 @@
+#!/bin/bash
+# drivers/rust.sh
+# Wraps rust-code-analysis-cli to produce standard complexity JSON
+#
+# Usage: ./drivers/rust.sh [directory]
+#        directory: Path to Rust code to analyze (default: current directory)
+#
+# Output: JSON conforming to ComplexityReport schema
+# Exit codes: 0 = success, 1 = error (rust-code-analysis-cli not installed or other failure)
+
+set -euo pipefail
+
+TARGET_DIR="${1:-.}"
+
+# Check rust-code-analysis-cli is installed
+if ! command -v rust-code-analysis-cli &> /dev/null; then
+    echo '{"error": "rust-code-analysis-cli not installed. Run: cargo install rust-code-analysis-cli"}' >&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 Rust files
+if ! find "$TARGET_DIR" -name "*.rs" ! -path "*/target/*" -print -quit 2>/dev/null | grep -q .; then
+    # No Rust files found, output empty result
+    echo '{"tool":"rust-code-analysis","language":"rust","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 rust-code-analysis-cli and transform output
+# The tool outputs JSON with metrics for each file analyzed
+# We need to transform this to match our ComplexityReport schema
+
+# Create temp directory for JSON outputs
+TEMP_DIR=$(mktemp -d)
+trap "rm -rf $TEMP_DIR" EXIT
+
+# Run rust-code-analysis-cli on the directory
+# -m: enable metrics computation
+# -O json: output format JSON
+# -p: path to analyze
+# Output goes to current directory with .json extension added to original filename
+(cd "$TEMP_DIR" && rust-code-analysis-cli -m -p "$TARGET_DIR" -O json 2>/dev/null) || {
+    echo '{"error": "rust-code-analysis-cli failed to analyze code"}' >&2
+    exit 1
+}
+
+# Find all generated JSON files and merge them
+# rust-code-analysis creates one JSON per source file
+find "$TEMP_DIR" -name "*.json" -type f 2>/dev/null | jq -s -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 each file'\''s metrics
+map(
+  # Extract the original file path from name field
+  .name as $filepath |
+
+  # Get cyclomatic complexity for functions
+  (.spaces // []) |
+
+  # Find all functions and their complexity
+  [.. | select(.kind? == "function" or .kind? == "method") | {
+    name: .name.name,
+    complexity: (.metrics.cyclomatic.sum // 0),
+    line: .start_line,
+    endLine: .end_line
+  }] as $functions |
+
+  # Calculate file-level metrics
+  {
+    key: $filepath,
+    value: {
+      functions: ($functions | map(
+        . + {grade: (.complexity | complexity_to_grade)}
+      )),
+      avgComplexity: (
+        if ($functions | length) > 0 then
+          (($functions | map(.complexity) | add) / ($functions | length))
+        else 0 end
+      ),
+      maxComplexity: (
+        if ($functions | length) > 0 then
+          ($functions | map(.complexity) | max)
+        else 0 end
+      ),
+      grade: (
+        if ($functions | length) > 0 then
+          ((($functions | map(.complexity) | add) / ($functions | length)) | complexity_to_grade)
+        else "A" end
+      )
+    }
+  }
+) |
+
+# Convert to object with file paths as keys
+from_entries as $files |
+
+# Build final output
+{
+  tool: "rust-code-analysis",
+  language: "rust",
+  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/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "@boshu2/vibe-check",
-  "version": "2.2.1",
+  "version": "2.4.0",
   "description": "Track git commit patterns during AI-assisted coding (experimental)",
   "main": "dist/cli.js",
   "bin": {
@@ -33,9 +33,12 @@
     "commander": "^14.0.2",
     "date-fns": "^4.1.0",
     "enquirer": "^2.4.1",
+    "js-yaml": "^4.1.1",
+    "minimatch": "^10.1.1",
     "simple-git": "^3.30.0"
   },
   "devDependencies": {
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^25.0.2",
     "@vitest/coverage-v8": "^4.0.15",
     "ts-node": "^10.9.2",